| Directory: | ./ |
|---|---|
| File: | sql/binlog.cc |
| Date: | 2022-12-13 11:44:05 |
| Exec | Total | Coverage | |
|---|---|---|---|
| Lines: | 4228 | 4700 | 90.0% |
| Branches: | 5373 | 10093 | 53.2% |
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* Copyright (c) 2009, 2022, Oracle and/or its affiliates. | ||
| 2 | |||
| 3 | This program is free software; you can redistribute it and/or modify | ||
| 4 | it under the terms of the GNU General Public License, version 2.0, | ||
| 5 | as published by the Free Software Foundation. | ||
| 6 | |||
| 7 | This program is also distributed with certain software (including | ||
| 8 | but not limited to OpenSSL) that is licensed under separate terms, | ||
| 9 | as designated in a particular file or component or in included license | ||
| 10 | documentation. The authors of MySQL hereby grant you an additional | ||
| 11 | permission to link the program and your derivative works with the | ||
| 12 | separately licensed software that they have included with MySQL. | ||
| 13 | |||
| 14 | This program is distributed in the hope that it will be useful, | ||
| 15 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 17 | GNU General Public License, version 2.0, for more details. | ||
| 18 | |||
| 19 | You should have received a copy of the GNU General Public License | ||
| 20 | along with this program; if not, write to the Free Software | ||
| 21 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ | ||
| 22 | |||
| 23 | #include "sql/binlog.h" | ||
| 24 | |||
| 25 | #include "my_config.h" | ||
| 26 | |||
| 27 | #include <errno.h> | ||
| 28 | #include <fcntl.h> | ||
| 29 | #include <limits.h> | ||
| 30 | #include <stdio.h> | ||
| 31 | #include <stdlib.h> | ||
| 32 | #include <time.h> | ||
| 33 | |||
| 34 | #include "lex_string.h" | ||
| 35 | #include "map_helpers.h" | ||
| 36 | #include "my_alloc.h" | ||
| 37 | #include "my_loglevel.h" | ||
| 38 | #include "my_macros.h" | ||
| 39 | #include "my_systime.h" | ||
| 40 | #include "my_thread.h" | ||
| 41 | #include "sql/check_stack.h" | ||
| 42 | #include "sql/clone_handler.h" | ||
| 43 | #include "sql_string.h" | ||
| 44 | #include "template_utils.h" | ||
| 45 | #ifdef HAVE_UNISTD_H | ||
| 46 | #include <unistd.h> | ||
| 47 | #endif | ||
| 48 | #include <algorithm> | ||
| 49 | #include <list> | ||
| 50 | #include <map> | ||
| 51 | #include <new> | ||
| 52 | #include <queue> | ||
| 53 | #include <sstream> | ||
| 54 | #include <string> | ||
| 55 | |||
| 56 | #include "dur_prop.h" | ||
| 57 | #include "libbinlogevents/include/compression/base.h" | ||
| 58 | #include "libbinlogevents/include/compression/iterator.h" | ||
| 59 | #include "libbinlogevents/include/control_events.h" | ||
| 60 | #include "libbinlogevents/include/debug_vars.h" | ||
| 61 | #include "libbinlogevents/include/rows_event.h" | ||
| 62 | #include "libbinlogevents/include/statement_events.h" | ||
| 63 | #include "libbinlogevents/include/table_id.h" | ||
| 64 | #include "mf_wcomp.h" // wild_one, wild_many | ||
| 65 | #include "mutex_lock.h" // Mutex_lock | ||
| 66 | #include "my_base.h" | ||
| 67 | #include "my_bitmap.h" | ||
| 68 | #include "my_byteorder.h" | ||
| 69 | #include "my_compiler.h" | ||
| 70 | #include "my_dbug.h" | ||
| 71 | #include "my_dir.h" | ||
| 72 | #include "my_sqlcommand.h" | ||
| 73 | #include "my_stacktrace.h" // my_safe_print_system_time | ||
| 74 | #include "my_thread_local.h" | ||
| 75 | #include "mysql/components/services/log_builtins.h" | ||
| 76 | #include "mysql/plugin.h" | ||
| 77 | #include "mysql/psi/mysql_file.h" | ||
| 78 | #include "mysql/service_mysql_alloc.h" | ||
| 79 | #include "mysql/thread_type.h" | ||
| 80 | #include "mysqld_error.h" | ||
| 81 | #include "partition_info.h" | ||
| 82 | #include "prealloced_array.h" | ||
| 83 | #include "sql/binlog/global.h" | ||
| 84 | #include "sql/binlog/recovery.h" // binlog::Binlog_recovery | ||
| 85 | #include "sql/binlog/tools/iterators.h" | ||
| 86 | #include "sql/binlog_ostream.h" | ||
| 87 | #include "sql/binlog_reader.h" | ||
| 88 | #include "sql/create_field.h" | ||
| 89 | #include "sql/current_thd.h" | ||
| 90 | #include "sql/debug_sync.h" // DEBUG_SYNC | ||
| 91 | #include "sql/derror.h" // ER_THD | ||
| 92 | #include "sql/discrete_interval.h" | ||
| 93 | #include "sql/field.h" | ||
| 94 | #include "sql/handler.h" | ||
| 95 | #include "sql/item_func.h" // user_var_entry | ||
| 96 | #include "sql/key.h" | ||
| 97 | #include "sql/log.h" | ||
| 98 | #include "sql/log_event.h" // Rows_log_event | ||
| 99 | #include "sql/mysqld.h" // sync_binlog_period ... | ||
| 100 | #include "sql/mysqld_thd_manager.h" // Global_THD_manager | ||
| 101 | #include "sql/protocol.h" | ||
| 102 | #include "sql/psi_memory_key.h" | ||
| 103 | #include "sql/query_options.h" | ||
| 104 | #include "sql/raii/sentry.h" // raii::Sentry<> | ||
| 105 | #include "sql/rpl_filter.h" | ||
| 106 | #include "sql/rpl_gtid.h" | ||
| 107 | #include "sql/rpl_handler.h" // RUN_HOOK | ||
| 108 | #include "sql/rpl_mi.h" // Master_info | ||
| 109 | #include "sql/rpl_record.h" | ||
| 110 | #include "sql/rpl_replica.h" | ||
| 111 | #include "sql/rpl_replica_commit_order_manager.h" // Commit_order_manager | ||
| 112 | #include "sql/rpl_rli.h" // Relay_log_info | ||
| 113 | #include "sql/rpl_rli_pdb.h" // Slave_worker | ||
| 114 | #include "sql/rpl_transaction_ctx.h" | ||
| 115 | #include "sql/rpl_trx_boundary_parser.h" // Transaction_boundary_parser | ||
| 116 | #include "sql/rpl_utility.h" | ||
| 117 | #include "sql/sql_backup_lock.h" // is_instance_backup_locked | ||
| 118 | #include "sql/sql_base.h" // find_temporary_table | ||
| 119 | #include "sql/sql_bitmap.h" | ||
| 120 | #include "sql/sql_class.h" // THD | ||
| 121 | #include "sql/sql_const.h" | ||
| 122 | #include "sql/sql_data_change.h" | ||
| 123 | #include "sql/sql_error.h" | ||
| 124 | #include "sql/sql_lex.h" | ||
| 125 | #include "sql/sql_list.h" | ||
| 126 | #include "sql/sql_parse.h" // sqlcom_can_generate_row_events | ||
| 127 | #include "sql/sql_show.h" // append_identifier | ||
| 128 | #include "sql/system_variables.h" | ||
| 129 | #include "sql/table.h" | ||
| 130 | #include "sql/transaction_info.h" | ||
| 131 | #include "sql/xa.h" | ||
| 132 | #include "sql/xa/sql_cmd_xa.h" // Sql_cmd_xa_* | ||
| 133 | #include "sql_partition.h" | ||
| 134 | #include "thr_lock.h" | ||
| 135 | |||
| 136 | class Item; | ||
| 137 | |||
| 138 | using binary_log::checksum_crc32; | ||
| 139 | using std::list; | ||
| 140 | |||
| 141 | #ifdef WITH_WSREP | ||
| 142 | #include "wsrep_binlog.h" | ||
| 143 | #include "wsrep_trans_observer.h" | ||
| 144 | #include "wsrep_xid.h" | ||
| 145 | #endif /* WITH_WSREP */ | ||
| 146 | |||
| 147 | using std::max; | ||
| 148 | using std::min; | ||
| 149 | using std::string; | ||
| 150 | |||
| 151 | #define FLAGSTR(V, F) ((V) & (F) ? #F " " : "") | ||
| 152 | #define YESNO(X) ((X) ? "yes" : "no") | ||
| 153 | |||
| 154 | /** | ||
| 155 | @defgroup Binary_Log Binary Log | ||
| 156 | @{ | ||
| 157 | */ | ||
| 158 | |||
| 159 | #define MY_OFF_T_UNDEF (~(my_off_t)0UL) | ||
| 160 | |||
| 161 | /* | ||
| 162 | Constants required for the limit unsafe warnings suppression | ||
| 163 | */ | ||
| 164 | // seconds after which the limit unsafe warnings suppression will be activated | ||
| 165 | #define LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT 50 | ||
| 166 | // number of limit unsafe warnings after which the suppression will be activated | ||
| 167 | #define LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT 50 | ||
| 168 | |||
| 169 | static ulonglong limit_unsafe_suppression_start_time = 0; | ||
| 170 | static bool unsafe_warning_suppression_is_activated = false; | ||
| 171 | static int limit_unsafe_warning_count = 0; | ||
| 172 | |||
| 173 | #ifdef WITH_WSREP | ||
| 174 | handlerton *binlog_hton; // we need it in wsrep_binlog.cc so skip static | ||
| 175 | #else | ||
| 176 | static handlerton *binlog_hton; | ||
| 177 | #endif /* WITH_WSREP */ | ||
| 178 | bool opt_binlog_order_commits = true; | ||
| 179 | |||
| 180 | const char *log_bin_index = nullptr; | ||
| 181 | const char *log_bin_basename = nullptr; | ||
| 182 | |||
| 183 | /* Size for IO_CACHE buffer for binlog & relay log */ | ||
| 184 | ulong rpl_read_size; | ||
| 185 | |||
| 186 | MYSQL_BIN_LOG mysql_bin_log(&sync_binlog_period); | ||
| 187 | |||
| 188 | static int binlog_init(void *p); | ||
| 189 | static int binlog_start_trans_and_stmt(THD *thd, Log_event *start_event); | ||
| 190 | static int binlog_close_connection(handlerton *hton, THD *thd); | ||
| 191 | static int binlog_savepoint_set(handlerton *hton, THD *thd, void *sv); | ||
| 192 | static int binlog_savepoint_rollback(handlerton *hton, THD *thd, void *sv); | ||
| 193 | static bool binlog_savepoint_rollback_can_release_mdl(handlerton *hton, | ||
| 194 | THD *thd); | ||
| 195 | static int binlog_commit(handlerton *hton, THD *thd, bool all); | ||
| 196 | static int binlog_rollback(handlerton *hton, THD *thd, bool all); | ||
| 197 | /* | ||
| 198 | This function is used to prepare a transaction. For the binary log SE. | ||
| 199 | |||
| 200 | @param hton The pointer to the binlog SE plugin. | ||
| 201 | @param thd The THD session object holding the transaction to be prepared. | ||
| 202 | @param all Preparing a transaction (i.e. true) or a statement | ||
| 203 | (i.e. false). | ||
| 204 | |||
| 205 | @return 0 if the function is successfully executed, non-zero otherwise | ||
| 206 | */ | ||
| 207 | static int binlog_prepare(handlerton *hton, THD *thd, bool all); | ||
| 208 | /* | ||
| 209 | This function is used to mark an X/Open XA distributed transaction as | ||
| 210 | being prepared in the server transaction coordinator. | ||
| 211 | |||
| 212 | Is a no-op function, added to the handler API to workaround warnings that | ||
| 213 | are triggered for SEs participating in a transaction that requires this | ||
| 214 | callback but such callback is not available. | ||
| 215 | |||
| 216 | @param hton The pointer to the binlog SE plugin. | ||
| 217 | @param thd The THD session object holding the transaction to be updated. | ||
| 218 | |||
| 219 | @return 0 if the function is successfully executed, non-zero otherwise | ||
| 220 | */ | ||
| 221 | static int binlog_set_prepared_in_tc(handlerton *hton, THD *thd); | ||
| 222 | static void exec_binlog_error_action_abort(const char *err_string); | ||
| 223 | static void binlog_prepare_row_images(const THD *thd, TABLE *table); | ||
| 224 | static bool is_loggable_xa_prepare(THD *thd); | ||
| 225 | static int check_instance_backup_locked(); | ||
| 226 | |||
| 227 | namespace { | ||
| 228 | /** | ||
| 229 | Finishes the transaction in the engines. If the `commit_low` flag is set, | ||
| 230 | will commit in the engines, otherwise, if the underlying statement is an | ||
| 231 | `XA ROLLBACK`, it will rollback in the engines. | ||
| 232 | |||
| 233 | @param thd The THD session object holding the transaction to finalize. | ||
| 234 | @param all Finalizing a transaction (i.e. true) or a statement | ||
| 235 | (i.e. false). | ||
| 236 | @param run_after_commit In the case of a commit being issued, whether or | ||
| 237 | not to run the `after_commit` hook. | ||
| 238 | */ | ||
| 239 | void finish_transaction_in_engines(THD *thd, bool all, bool run_after_commit); | ||
| 240 | } // namespace | ||
| 241 | |||
| 242 | 2913078 | bool normalize_binlog_name(char *to, const char *from, bool is_relay_log) { | |
| 243 |
1/2✓ Branch 0 taken 2913078 times.
✗ Branch 1 not taken.
|
2913078 | DBUG_TRACE; |
| 244 | 2913078 | bool error = false; | |
| 245 | char buff[FN_REFLEN]; | ||
| 246 | 2913078 | char *ptr = const_cast<char *>(from); | |
| 247 |
2/2✓ Branch 0 taken 2341145 times.
✓ Branch 1 taken 571933 times.
|
2913078 | char *opt_name = is_relay_log ? opt_relay_logname : opt_bin_logname; |
| 248 | |||
| 249 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2913078 times.
|
2913078 | assert(from); |
| 250 | |||
| 251 | /* opt_name is not null and not empty and from is a relative path */ | ||
| 252 |
8/12✓ Branch 0 taken 2913078 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2913078 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2913078 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2913078 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2912873 times.
✓ Branch 9 taken 205 times.
✓ Branch 10 taken 2912873 times.
✓ Branch 11 taken 205 times.
|
2913078 | if (opt_name && opt_name[0] && from && !test_if_hard_path(from)) { |
| 253 | // take the path from opt_name | ||
| 254 | // take the filename from from | ||
| 255 | char log_dirpart[FN_REFLEN], log_dirname[FN_REFLEN]; | ||
| 256 | size_t log_dirpart_len, log_dirname_len; | ||
| 257 |
1/2✓ Branch 0 taken 2912873 times.
✗ Branch 1 not taken.
|
2912873 | dirname_part(log_dirpart, opt_name, &log_dirpart_len); |
| 258 |
1/2✓ Branch 0 taken 2912873 times.
✗ Branch 1 not taken.
|
2912873 | dirname_part(log_dirname, from, &log_dirname_len); |
| 259 | |||
| 260 | /* log may be empty => relay-log or log-bin did not | ||
| 261 | hold paths, just filename pattern */ | ||
| 262 |
2/2✓ Branch 0 taken 54 times.
✓ Branch 1 taken 2912819 times.
|
2912873 | if (log_dirpart_len > 0) { |
| 263 | /* create the new path name */ | ||
| 264 |
1/2✓ Branch 0 taken 54 times.
✗ Branch 1 not taken.
|
54 | if (fn_format(buff, from + log_dirname_len, log_dirpart, "", |
| 265 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
|
54 | MYF(MY_UNPACK_FILENAME | MY_SAFE_PATH)) == nullptr) { |
| 266 | ✗ | error = true; | |
| 267 | ✗ | goto end; | |
| 268 | } | ||
| 269 | |||
| 270 | 54 | ptr = buff; | |
| 271 | } | ||
| 272 | } | ||
| 273 | |||
| 274 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2913078 times.
|
2913078 | assert(ptr); |
| 275 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2913078 times.
|
2913078 | if (ptr) { |
| 276 | 2913078 | size_t length = strlen(ptr); | |
| 277 | |||
| 278 | // Strips the CR+LF at the end of log name and \0-terminates it. | ||
| 279 |
3/4✓ Branch 0 taken 2913078 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2819660 times.
✓ Branch 3 taken 93418 times.
|
2913078 | if (length && ptr[length - 1] == '\n') { |
| 280 | 2819660 | ptr[length - 1] = 0; | |
| 281 | 2819660 | length--; | |
| 282 |
2/4✓ Branch 0 taken 2819660 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2819660 times.
|
2819660 | if (length && ptr[length - 1] == '\r') { |
| 283 | ✗ | ptr[length - 1] = 0; | |
| 284 | ✗ | length--; | |
| 285 | } | ||
| 286 | } | ||
| 287 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2913078 times.
|
2913078 | if (!length) { |
| 288 | ✗ | error = true; | |
| 289 | ✗ | goto end; | |
| 290 | } | ||
| 291 |
1/2✓ Branch 0 taken 2913078 times.
✗ Branch 1 not taken.
|
2913078 | strmake(to, ptr, length); |
| 292 | } | ||
| 293 | ✗ | end: | |
| 294 | 2913078 | return error; | |
| 295 | 2913078 | } | |
| 296 | |||
| 297 | static int binlog_start_consistent_snapshot(handlerton *hton, THD *thd); | ||
| 298 | static int binlog_clone_consistent_snapshot(handlerton *hton, THD *thd, | ||
| 299 | THD *from_thd); | ||
| 300 | |||
| 301 | ulonglong binlog_space_limit; | ||
| 302 | |||
| 303 | // The last published global binlog position | ||
| 304 | static char binlog_global_snapshot_file[FN_REFLEN]; | ||
| 305 | static ulonglong binlog_global_snapshot_position; | ||
| 306 | |||
| 307 | // Binlog position variables for SHOW STATUS | ||
| 308 | static char binlog_snapshot_file[FN_REFLEN]; | ||
| 309 | static ulonglong binlog_snapshot_position; | ||
| 310 | static std::string binlog_snapshot_gtid_executed; | ||
| 311 | |||
| 312 | static SHOW_VAR binlog_status_vars_detail[] = { | ||
| 313 | {"snapshot_file", (char *)&binlog_snapshot_file, SHOW_CHAR, | ||
| 314 | SHOW_SCOPE_GLOBAL}, | ||
| 315 | {"snapshot_position", (char *)&binlog_snapshot_position, SHOW_LONGLONG, | ||
| 316 | SHOW_SCOPE_GLOBAL}, | ||
| 317 | {NullS, NullS, SHOW_LONG, SHOW_SCOPE_GLOBAL}}; | ||
| 318 | |||
| 319 | /** | ||
| 320 | @brief Checks whether purge conditions are met to be able to run purge | ||
| 321 | for binary log files. | ||
| 322 | |||
| 323 | This function checks whether the binary log is open, if the instance | ||
| 324 | is not locked for backup. | ||
| 325 | |||
| 326 | @param log The reference to the binary log. | ||
| 327 | @return std::pair<bool, int> the first element states whether there is a | ||
| 328 | purge condition violation. The second element states what is the associated | ||
| 329 | error code, if any. | ||
| 330 | */ | ||
| 331 | 7109 | static std::pair<bool, int> check_purge_conditions(const MYSQL_BIN_LOG &log) { | |
| 332 | // is the binary log open? | ||
| 333 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 7107 times.
|
7109 | if (!log.is_open()) { |
| 334 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | return std::make_pair(true, 0); |
| 335 | } | ||
| 336 | |||
| 337 | // is instance locked for backup ? | ||
| 338 | 7107 | int error{0}; | |
| 339 |
3/4✓ Branch 0 taken 7107 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 7077 times.
|
7107 | if ((error = check_instance_backup_locked()) != 0) { |
| 340 |
1/2✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
|
30 | return std::make_pair(true, error); |
| 341 | } | ||
| 342 | |||
| 343 | // go ahead, validations checked successfully | ||
| 344 |
1/2✓ Branch 0 taken 7077 times.
✗ Branch 1 not taken.
|
7077 | return std::make_pair(false, 0); |
| 345 | } | ||
| 346 | |||
| 347 | /** | ||
| 348 | @brief This function abstracts the calculation of the binary log files | ||
| 349 | retention lower bound. It is just a function that makes it easier | ||
| 350 | to handle the fact that there are two mutually exclusive variables | ||
| 351 | that control the purge period and one of them is deprecated. | ||
| 352 | |||
| 353 | NOTE: This function and part of the purge validation functions should | ||
| 354 | really move to a retention policy class that abstracts the | ||
| 355 | retention policy altogether and its controls. Perhaps we | ||
| 356 | can do that once expire_logs_days is removed and a refactoring | ||
| 357 | is done to also include retention based on storage space | ||
| 358 | occupied. Then we can uses the same retention abstraction | ||
| 359 | for binary and relay logs and possibly extend the options | ||
| 360 | to retain (binary) log files not only based on time, but | ||
| 361 | also on space used. | ||
| 362 | |||
| 363 | @return time_t the time after which log files are considered expired. | ||
| 364 | */ | ||
| 365 | 31875 | static time_t calculate_auto_purge_lower_time_bound() { | |
| 366 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31875 times.
|
31875 | if (DBUG_EVALUATE_IF("expire_logs_always", true, false)) return time(nullptr); |
| 367 | |||
| 368 |
2/2✓ Branch 0 taken 31839 times.
✓ Branch 1 taken 36 times.
|
31875 | if (binlog_expire_logs_seconds > 0) |
| 369 | 31839 | return time(nullptr) - binlog_expire_logs_seconds; | |
| 370 |
1/2✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
|
36 | else if (expire_logs_days > 0) |
| 371 | 36 | return time(nullptr) - | |
| 372 | 36 | expire_logs_days * static_cast<time_t>(SECONDS_IN_24H); | |
| 373 | |||
| 374 | // This function should only be called if binlog_expire_logs_seconds | ||
| 375 | // or expire_logs_days are greater than 0. In debug builds assert. | ||
| 376 | // In the event that on production builds there is ever a bug, | ||
| 377 | // that causes the caller to call this function with expire time set | ||
| 378 | // to 0, then do not purge - return 0 and thus file stat time is | ||
| 379 | // always greater than purge time. | ||
| 380 | ✗ | assert(false); /* purecov: inspected */ | |
| 381 | return 0; /* purecov: inspected */ | ||
| 382 | } | ||
| 383 | |||
| 384 | /** | ||
| 385 | @brief Checks if automatic purge conditions are met and therefore the | ||
| 386 | purge is allowed to be done. If not met returns true. Otherwise, false. | ||
| 387 | |||
| 388 | @return false if the check is successful. True otherwise. | ||
| 389 | */ | ||
| 390 | 15981 | static bool check_auto_purge_conditions() { | |
| 391 | // purge is disabled | ||
| 392 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 15972 times.
|
15981 | if (!opt_binlog_expire_logs_auto_purge) return true; |
| 393 | |||
| 394 | // no retention window configured | ||
| 395 |
4/4✓ Branch 0 taken 37 times.
✓ Branch 1 taken 15935 times.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 18 times.
|
15972 | if (binlog_expire_logs_seconds == 0 && expire_logs_days == 0) return true; |
| 396 | |||
| 397 | // retention window is set, but we are still within the window | ||
| 398 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 15952 times.
|
15953 | if (calculate_auto_purge_lower_time_bound() < 0) return true; |
| 399 | |||
| 400 | // go ahead, validations checked successfully | ||
| 401 | 15952 | return false; | |
| 402 | } | ||
| 403 | |||
| 404 | /** | ||
| 405 | Logical binlog file which wraps and hides the detail of lower layer storage | ||
| 406 | implementation. Binlog code just use this class to control real storage | ||
| 407 | */ | ||
| 408 | class MYSQL_BIN_LOG::Binlog_ofile : public Basic_ostream { | ||
| 409 | public: | ||
| 410 | 514348 | ~Binlog_ofile() override { | |
| 411 | 257174 | DBUG_TRACE; | |
| 412 | 257174 | close(); | |
| 413 | 257172 | return; | |
| 414 | 514346 | } | |
| 415 | |||
| 416 | /** | ||
| 417 | Opens the binlog file. It opens the lower layer storage. | ||
| 418 | |||
| 419 | @param[in] log_file_key The PSI_file_key for this stream | ||
| 420 | @param[in] binlog_name The file to be opened | ||
| 421 | @param[in] flags The flags used by IO_CACHE. | ||
| 422 | @param[in] existing True if opening the file, false if creating a new one. | ||
| 423 | |||
| 424 | @retval false Success | ||
| 425 | @retval true Error | ||
| 426 | */ | ||
| 427 | 81761 | bool open( | |
| 428 | #ifdef HAVE_PSI_INTERFACE | ||
| 429 | PSI_file_key log_file_key, | ||
| 430 | #endif | ||
| 431 | const char *binlog_name, myf flags, bool existing = false) { | ||
| 432 |
1/2✓ Branch 0 taken 81761 times.
✗ Branch 1 not taken.
|
81761 | DBUG_TRACE; |
| 433 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 81761 times.
|
81761 | assert(m_pipeline_head == nullptr); |
| 434 | |||
| 435 | #ifndef NDEBUG | ||
| 436 | { | ||
| 437 | #ifndef HAVE_PSI_INTERFACE | ||
| 438 | PSI_file_key log_file_key = PSI_NOT_INSTRUMENTED; | ||
| 439 | #endif | ||
| 440 | MY_STAT info; | ||
| 441 |
3/4✓ Branch 0 taken 81760 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78858 times.
✓ Branch 3 taken 2902 times.
|
81761 | if (!mysql_file_stat(log_file_key, binlog_name, &info, MYF(0))) { |
| 442 |
2/4✓ Branch 0 taken 78857 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78857 times.
|
78858 | assert(existing == !(my_errno() == ENOENT)); |
| 443 |
1/2✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
|
78857 | set_my_errno(0); |
| 444 | } | ||
| 445 | } | ||
| 446 | #endif | ||
| 447 | |||
| 448 |
2/4✓ Branch 0 taken 81760 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 81758 times.
✗ Branch 3 not taken.
|
81760 | std::unique_ptr<IO_CACHE_ostream> file_ostream(new IO_CACHE_ostream); |
| 449 |
2/4✓ Branch 0 taken 81760 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 81760 times.
|
81760 | if (file_ostream->open(log_file_key, binlog_name, flags)) return true; |
| 450 | |||
| 451 | 81760 | m_pipeline_head = std::move(file_ostream); | |
| 452 | |||
| 453 | /* Setup encryption for new files if needed */ | ||
| 454 |
7/8✓ Branch 0 taken 78858 times.
✓ Branch 1 taken 2902 times.
✓ Branch 2 taken 78858 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 301 times.
✓ Branch 5 taken 78557 times.
✓ Branch 6 taken 301 times.
✓ Branch 7 taken 81459 times.
|
81760 | if (!existing && rpl_encryption.is_enabled()) { |
| 455 | std::unique_ptr<Binlog_encryption_ostream> encrypted_ostream( | ||
| 456 |
1/2✓ Branch 0 taken 301 times.
✗ Branch 1 not taken.
|
301 | new Binlog_encryption_ostream()); |
| 457 |
2/4✓ Branch 0 taken 301 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 301 times.
|
301 | if (encrypted_ostream->open(std::move(m_pipeline_head))) return true; |
| 458 |
1/2✓ Branch 0 taken 301 times.
✗ Branch 1 not taken.
|
301 | m_encrypted_header_size = encrypted_ostream->get_header_size(); |
| 459 | 301 | m_pipeline_head = std::move(encrypted_ostream); | |
| 460 |
1/2✓ Branch 0 taken 301 times.
✗ Branch 1 not taken.
|
301 | } |
| 461 | |||
| 462 | 81760 | return false; | |
| 463 | 81760 | } | |
| 464 | |||
| 465 | /** | ||
| 466 | Opens an existing binlog file. It opens the lower layer storage reusing the | ||
| 467 | existing file password if needed. | ||
| 468 | |||
| 469 | @param[in] log_file_key The PSI_file_key for this stream | ||
| 470 | @param[in] binlog_name The file to be opened | ||
| 471 | @param[in] flags The flags used by IO_CACHE. | ||
| 472 | |||
| 473 | @retval std::unique_ptr A Binlog_ofile object pointer. | ||
| 474 | @retval nullptr Error. | ||
| 475 | */ | ||
| 476 | 2903 | static std::unique_ptr<Binlog_ofile> open_existing( | |
| 477 | #ifdef HAVE_PSI_INTERFACE | ||
| 478 | PSI_file_key log_file_key, | ||
| 479 | #endif | ||
| 480 | const char *binlog_name, myf flags) { | ||
| 481 |
1/2✓ Branch 0 taken 2903 times.
✗ Branch 1 not taken.
|
2903 | DBUG_TRACE; |
| 482 | 2903 | std::unique_ptr<Rpl_encryption_header> header; | |
| 483 | unsigned char magic[BINLOG_MAGIC_SIZE]; | ||
| 484 | |||
| 485 | /* Open a simple istream to read the magic from the file */ | ||
| 486 |
1/2✓ Branch 0 taken 2903 times.
✗ Branch 1 not taken.
|
2903 | IO_CACHE_istream istream; |
| 487 |
3/4✓ Branch 0 taken 2903 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2902 times.
|
2903 | if (istream.open(key_file_binlog, key_file_binlog_cache, binlog_name, |
| 488 | MYF(MY_WME | MY_DONT_CHECK_FILESIZE), rpl_read_size)) | ||
| 489 | 1 | return nullptr; | |
| 490 |
2/4✓ Branch 0 taken 2902 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2902 times.
|
2902 | if (istream.read(magic, BINLOG_MAGIC_SIZE) != BINLOG_MAGIC_SIZE) |
| 491 | ✗ | return nullptr; | |
| 492 | |||
| 493 | assert(Rpl_encryption_header::ENCRYPTION_MAGIC_SIZE == BINLOG_MAGIC_SIZE); | ||
| 494 | /* Identify the file type by the magic to get the encryption header */ | ||
| 495 |
2/2✓ Branch 0 taken 1100 times.
✓ Branch 1 taken 1802 times.
|
2902 | if (memcmp(magic, Rpl_encryption_header::ENCRYPTION_MAGIC, |
| 496 | BINLOG_MAGIC_SIZE) == 0) { | ||
| 497 |
1/2✓ Branch 0 taken 1100 times.
✗ Branch 1 not taken.
|
1100 | header = Rpl_encryption_header::get_header(&istream); |
| 498 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1100 times.
|
1100 | if (header == nullptr) return nullptr; |
| 499 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1802 times.
|
1802 | } else if (memcmp(magic, BINLOG_MAGIC, BINLOG_MAGIC_SIZE) != 0) { |
| 500 | ✗ | return nullptr; | |
| 501 | } | ||
| 502 | |||
| 503 | /* Open the binlog_ofile */ | ||
| 504 |
1/2✓ Branch 0 taken 2902 times.
✗ Branch 1 not taken.
|
2902 | std::unique_ptr<Binlog_ofile> ret_ofile(new Binlog_ofile); |
| 505 |
2/4✓ Branch 0 taken 2902 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2902 times.
|
2902 | if (ret_ofile->open( |
| 506 | #ifdef HAVE_PSI_INTERFACE | ||
| 507 | log_file_key, | ||
| 508 | #endif | ||
| 509 | binlog_name, flags, true)) { | ||
| 510 | ✗ | return nullptr; | |
| 511 | } | ||
| 512 | |||
| 513 |
2/2✓ Branch 0 taken 1100 times.
✓ Branch 1 taken 1802 times.
|
2902 | if (header != nullptr) { |
| 514 | /* Add the encryption stream on top of IO_CACHE */ | ||
| 515 | std::unique_ptr<Binlog_encryption_ostream> encrypted_ostream( | ||
| 516 |
1/2✓ Branch 0 taken 1100 times.
✗ Branch 1 not taken.
|
1100 | new Binlog_encryption_ostream); |
| 517 |
1/2✓ Branch 0 taken 1100 times.
✗ Branch 1 not taken.
|
1100 | ret_ofile->m_encrypted_header_size = header->get_header_size(); |
| 518 |
1/2✓ Branch 0 taken 1100 times.
✗ Branch 1 not taken.
|
2200 | encrypted_ostream->open(std::move(ret_ofile->m_pipeline_head), |
| 519 | 1100 | std::move(header)); | |
| 520 | 1100 | ret_ofile->m_pipeline_head = std::move(encrypted_ostream); | |
| 521 | 1100 | ret_ofile->set_encrypted(); | |
| 522 | 1100 | } | |
| 523 | 2902 | return ret_ofile; | |
| 524 | 2903 | } | |
| 525 | |||
| 526 | 205831 | void close() { | |
| 527 | 205831 | m_pipeline_head.reset(nullptr); | |
| 528 | 205830 | m_position = 0; | |
| 529 | 205830 | m_encrypted_header_size = 0; | |
| 530 | 205830 | } | |
| 531 | |||
| 532 | /** | ||
| 533 | Writes data into storage and maintains binlog position. | ||
| 534 | |||
| 535 | @param[in] buffer the data will be written | ||
| 536 | @param[in] length the length of the data | ||
| 537 | |||
| 538 | @retval false Success | ||
| 539 | @retval true Error | ||
| 540 | */ | ||
| 541 | 55156035 | bool write(const unsigned char *buffer, my_off_t length) override { | |
| 542 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55156026 times.
|
55156035 | assert(m_pipeline_head != nullptr); |
| 543 | |||
| 544 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55156015 times.
|
55156026 | if (m_pipeline_head->write(buffer, length)) return true; |
| 545 | |||
| 546 | 55156015 | m_position += length; | |
| 547 | 55156015 | return false; | |
| 548 | } | ||
| 549 | |||
| 550 | /** | ||
| 551 | Updates some bytes in the binlog file. If is only used for clearing | ||
| 552 | LOG_EVENT_BINLOG_IN_USE_F. | ||
| 553 | |||
| 554 | @param[in] buffer the data will be written | ||
| 555 | @param[in] length the length of the data | ||
| 556 | @param[in] offset the offset of the bytes will be updated | ||
| 557 | |||
| 558 | @retval false Success | ||
| 559 | @retval true Error | ||
| 560 | */ | ||
| 561 | 26602 | bool update(const unsigned char *buffer, my_off_t length, my_off_t offset) { | |
| 562 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26602 times.
|
26602 | assert(m_pipeline_head != nullptr); |
| 563 |
1/2✓ Branch 0 taken 26602 times.
✗ Branch 1 not taken.
|
53204 | return m_pipeline_head->seek(offset) || |
| 564 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26602 times.
|
53204 | m_pipeline_head->write(buffer, length); |
| 565 | } | ||
| 566 | |||
| 567 | /** | ||
| 568 | Truncates some data at the end of the binlog file. | ||
| 569 | |||
| 570 | @param[in] offset where the binlog file will be truncated to. | ||
| 571 | |||
| 572 | @retval false Success | ||
| 573 | @retval true Error | ||
| 574 | */ | ||
| 575 | 12 | bool truncate(my_off_t offset) { | |
| 576 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | assert(m_pipeline_head != nullptr); |
| 577 | |||
| 578 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (m_pipeline_head->truncate(offset)) return true; |
| 579 | 12 | m_position = offset; | |
| 580 | 12 | return false; | |
| 581 | } | ||
| 582 | |||
| 583 | 4284951 | bool flush() { return m_pipeline_head->flush(); } | |
| 584 | 2618327 | bool sync() { return m_pipeline_head->sync(); } | |
| 585 |
3/4✓ Branch 0 taken 156100 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 156095 times.
|
156102 | bool flush_and_sync() { return flush() || sync(); } |
| 586 | 16209267 | my_off_t position() { return m_position; } | |
| 587 | 78858 | bool is_empty() { return position() == 0; } | |
| 588 | 2497490 | bool is_open() { return m_pipeline_head != nullptr; } | |
| 589 | /** | ||
| 590 | Returns the encrypted header size of the binary log file. | ||
| 591 | |||
| 592 | @retval 0 The file is not encrypted. | ||
| 593 | @retval >0 The encryption header size. | ||
| 594 | */ | ||
| 595 | 1449981 | int get_encrypted_header_size() { return m_encrypted_header_size; } | |
| 596 | /** | ||
| 597 | Returns the real file size. | ||
| 598 | |||
| 599 | While position() returns the "file size" from the plain binary log events | ||
| 600 | stream point of view, this function considers the encryption header when it | ||
| 601 | exists. | ||
| 602 | |||
| 603 | @return The real file size considering the encryption header. | ||
| 604 | */ | ||
| 605 | 4386051 | my_off_t get_real_file_size() { return m_position + m_encrypted_header_size; } | |
| 606 | /** | ||
| 607 | Get the pipeline head. | ||
| 608 | |||
| 609 | @retval Returns the pipeline head or nullptr. | ||
| 610 | */ | ||
| 611 | 1070 | std::unique_ptr<Truncatable_ostream> get_pipeline_head() { | |
| 612 | 1070 | return std::move(m_pipeline_head); | |
| 613 | } | ||
| 614 | /** | ||
| 615 | Check if the log file is encrypted. | ||
| 616 | |||
| 617 | @retval True if the log file is encrypted. | ||
| 618 | @retval False if the log file is not encrypted. | ||
| 619 | */ | ||
| 620 | 1158 | bool is_encrypted() { return m_encrypted; } | |
| 621 | /** | ||
| 622 | Set that the log file is encrypted. | ||
| 623 | */ | ||
| 624 | 1100 | void set_encrypted() { m_encrypted = true; } | |
| 625 | |||
| 626 | private: | ||
| 627 | my_off_t m_position = 0; | ||
| 628 | int m_encrypted_header_size = 0; | ||
| 629 | std::unique_ptr<Truncatable_ostream> m_pipeline_head; | ||
| 630 | bool m_encrypted = false; | ||
| 631 | }; | ||
| 632 | |||
| 633 | /** | ||
| 634 | Helper class to switch to a new thread and then go back to the previous one, | ||
| 635 | when the object is destroyed using RAII. | ||
| 636 | |||
| 637 | This class is used to temporarily switch to another session (THD | ||
| 638 | structure). It will set up thread specific "globals" correctly | ||
| 639 | so that the POSIX thread looks exactly like the session attached to. | ||
| 640 | However, PSI_thread info is not touched as it is required to show | ||
| 641 | the actual physical view in PFS instrumentation i.e., it should | ||
| 642 | depict as the real thread doing the work instead of thread it switched | ||
| 643 | to. | ||
| 644 | |||
| 645 | On destruction, the original session (which is supplied to the | ||
| 646 | constructor) will be re-attached automatically. For example, with | ||
| 647 | this code, the value of @c current_thd will be the same before and | ||
| 648 | after execution of the code. | ||
| 649 | |||
| 650 | @code | ||
| 651 | { | ||
| 652 | for (int i = 0 ; i < count ; ++i) | ||
| 653 | { | ||
| 654 | // here we are attached to current_thd | ||
| 655 | // [...] | ||
| 656 | Thd_backup_and_restore switch_thd(current_thd, other_thd[i]); | ||
| 657 | // [...] | ||
| 658 | // here we are attached to other_thd[i] | ||
| 659 | // [...] | ||
| 660 | } | ||
| 661 | // here we are attached to current_thd | ||
| 662 | } | ||
| 663 | @endcode | ||
| 664 | |||
| 665 | @warning The class is not designed to be inherited from. | ||
| 666 | */ | ||
| 667 | |||
| 668 | class Thd_backup_and_restore { | ||
| 669 | public: | ||
| 670 | /** | ||
| 671 | Try to attach the POSIX thread to a session. | ||
| 672 | |||
| 673 | @param[in] backup_thd The thd to restore to when object is destructed. | ||
| 674 | @param[in] new_thd The thd to attach to. | ||
| 675 | */ | ||
| 676 | |||
| 677 | 10337180 | Thd_backup_and_restore(THD *backup_thd, THD *new_thd) | |
| 678 | 10337180 | : m_backup_thd(backup_thd), | |
| 679 | 10337180 | m_new_thd(new_thd), | |
| 680 | 10337180 | m_new_thd_old_real_id(new_thd->real_id), | |
| 681 | 10337180 | m_new_thd_old_thread_stack(new_thd->thread_stack) { | |
| 682 |
2/4✓ Branch 0 taken 10337195 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10337195 times.
✗ Branch 3 not taken.
|
10337180 | assert(m_backup_thd != nullptr && m_new_thd != nullptr); |
| 683 | // Reset the state of the current thd. | ||
| 684 | 10337195 | m_backup_thd->restore_globals(); | |
| 685 | |||
| 686 | 10337192 | m_new_thd->thread_stack = m_backup_thd->thread_stack; | |
| 687 | 10337192 | m_new_thd->store_globals(); | |
| 688 | #ifdef HAVE_PSI_THREAD_INTERFACE | ||
| 689 | 10337176 | PSI_THREAD_CALL(set_mem_cnt_THD)(m_new_thd, &m_backup_cnt_thd); | |
| 690 | #endif | ||
| 691 | 10337173 | } | |
| 692 | |||
| 693 | /** | ||
| 694 | Restores to previous thd. | ||
| 695 | */ | ||
| 696 | 10337190 | ~Thd_backup_and_restore() { | |
| 697 | /* | ||
| 698 | Restore the global variables of the thd we previously attached to, | ||
| 699 | to its original state. In other words, detach the m_new_thd. | ||
| 700 | */ | ||
| 701 | 10337190 | m_new_thd->restore_globals(); | |
| 702 | 10337198 | m_new_thd->real_id = m_new_thd_old_real_id; | |
| 703 | 10337198 | m_new_thd->thread_stack = m_new_thd_old_thread_stack; | |
| 704 | |||
| 705 | // Reset the global variables to the original state. | ||
| 706 | 10337198 | m_backup_thd->store_globals(); | |
| 707 | #ifdef HAVE_PSI_THREAD_INTERFACE | ||
| 708 | 10337190 | PSI_THREAD_CALL(set_mem_cnt_THD)(m_backup_cnt_thd, &m_dummy_cnt_thd); | |
| 709 | #endif | ||
| 710 | 10337190 | } | |
| 711 | |||
| 712 | private: | ||
| 713 | THD *m_backup_thd; | ||
| 714 | THD *m_new_thd; | ||
| 715 | THD *m_backup_cnt_thd; | ||
| 716 | THD *m_dummy_cnt_thd; | ||
| 717 | my_thread_t m_new_thd_old_real_id; | ||
| 718 | const char *m_new_thd_old_thread_stack; | ||
| 719 | }; | ||
| 720 | |||
| 721 | /** | ||
| 722 | Caches for non-transactional and transactional data before writing | ||
| 723 | it to the binary log. | ||
| 724 | |||
| 725 | @todo All the access functions for the flags suggest that the | ||
| 726 | encapsuling is not done correctly, so try to move any logic that | ||
| 727 | requires access to the flags into the cache. | ||
| 728 | */ | ||
| 729 | class binlog_cache_data { | ||
| 730 | public: | ||
| 731 | 84058 | binlog_cache_data(bool trx_cache_arg, ulong *ptr_binlog_cache_use_arg, | |
| 732 | ulong *ptr_binlog_cache_disk_use_arg) | ||
| 733 | 168116 | : m_pending(nullptr), | |
| 734 | 84058 | ptr_binlog_cache_use(ptr_binlog_cache_use_arg), | |
| 735 |
1/2✓ Branch 0 taken 84058 times.
✗ Branch 1 not taken.
|
84058 | ptr_binlog_cache_disk_use(ptr_binlog_cache_disk_use_arg) { |
| 736 | 84058 | flags.transactional = trx_cache_arg; | |
| 737 | 84058 | } | |
| 738 | |||
| 739 | 84058 | bool open(my_off_t cache_size, my_off_t max_cache_size) { | |
| 740 | 84058 | return m_cache.open(cache_size, max_cache_size); | |
| 741 | } | ||
| 742 | |||
| 743 | 3763045 | Binlog_cache_storage *get_cache() { return &m_cache; } | |
| 744 | int finalize(THD *thd, Log_event *end_event); | ||
| 745 | int finalize(THD *thd, Log_event *end_event, XID_STATE *xs); | ||
| 746 | int flush(THD *thd, my_off_t *bytes, bool *wrote_xid); | ||
| 747 | int write_event(Log_event *event); | ||
| 748 | 2590253 | size_t get_event_counter() { return event_counter; } | |
| 749 | 2590011 | size_t get_compressed_size() { return m_compressed_size; } | |
| 750 | 2590011 | size_t get_decompressed_size() { return m_decompressed_size; } | |
| 751 | 2590011 | binary_log::transaction::compression::type get_compression_type() { | |
| 752 | 2590011 | return m_compression_type; | |
| 753 | } | ||
| 754 | |||
| 755 | 2590983 | void set_compressed_size(size_t s) { m_compressed_size = s; } | |
| 756 | 2591044 | void set_decompressed_size(size_t s) { m_decompressed_size = s; } | |
| 757 | 2590899 | void set_compression_type(binary_log::transaction::compression::type t) { | |
| 758 | 2590899 | m_compression_type = t; | |
| 759 | 2590899 | } | |
| 760 | |||
| 761 | 163066 | virtual ~binlog_cache_data() { | |
| 762 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 81578 times.
|
163066 | assert(is_binlog_empty()); |
| 763 | 163156 | m_cache.close(); | |
| 764 | } | ||
| 765 | |||
| 766 | 60940869 | bool is_binlog_empty() const { | |
| 767 |
4/4✓ Branch 0 taken 3108 times.
✓ Branch 1 taken 60938916 times.
✓ Branch 2 taken 1776 times.
✓ Branch 3 taken 1332 times.
|
60940869 | DBUG_PRINT("debug", ("%s_cache - pending: 0x%llx, bytes: %llu", |
| 768 | (flags.transactional ? "trx" : "stmt"), | ||
| 769 | (ulonglong)pending(), (ulonglong)m_cache.length())); | ||
| 770 |
4/4✓ Branch 0 taken 60789548 times.
✓ Branch 1 taken 152465 times.
✓ Branch 2 taken 40423829 times.
✓ Branch 3 taken 20367360 times.
|
60942024 | return pending() == nullptr && m_cache.is_empty(); |
| 771 | } | ||
| 772 | |||
| 773 | 5393750 | bool is_finalized() const { return flags.finalized; } | |
| 774 | |||
| 775 | 138079648 | Rows_log_event *pending() const { return m_pending; } | |
| 776 | |||
| 777 | 8855756 | void set_pending(Rows_log_event *const pending) { m_pending = pending; } | |
| 778 | |||
| 779 | 11 | void set_incident(void) { flags.incident = true; } | |
| 780 | |||
| 781 | 2604513 | bool has_incident(void) const { return flags.incident; } | |
| 782 | |||
| 783 | 4685252 | bool has_xid() const { | |
| 784 | // There should only be an XID event if we are transactional | ||
| 785 |
5/6✓ Branch 0 taken 2099936 times.
✓ Branch 1 taken 2585316 times.
✓ Branch 2 taken 317939 times.
✓ Branch 3 taken 1781997 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 4367313 times.
|
4685252 | assert((flags.transactional && flags.with_xid) || !flags.with_xid); |
| 786 | 4685252 | return flags.with_xid; | |
| 787 | } | ||
| 788 | |||
| 789 | 2590142 | bool is_trx_cache() const { return flags.transactional; } | |
| 790 | |||
| 791 | 7450032 | my_off_t get_byte_position() const { return m_cache.length(); } | |
| 792 | |||
| 793 | 15618853 | void cache_state_checkpoint(my_off_t pos_to_checkpoint) { | |
| 794 | // We only need to store the cache state for pos > 0 | ||
| 795 |
2/2✓ Branch 0 taken 10721432 times.
✓ Branch 1 taken 4897421 times.
|
15618853 | if (pos_to_checkpoint) { |
| 796 | cache_state state; | ||
| 797 | 10721432 | state.with_rbr = flags.with_rbr; | |
| 798 | 10721432 | state.with_sbr = flags.with_sbr; | |
| 799 | 10721432 | state.with_start = flags.with_start; | |
| 800 | 10721432 | state.with_end = flags.with_end; | |
| 801 | 10721432 | state.with_content = flags.with_content; | |
| 802 | 10721432 | state.event_counter = event_counter; | |
| 803 |
1/2✓ Branch 0 taken 10721330 times.
✗ Branch 1 not taken.
|
10721432 | cache_state_map[pos_to_checkpoint] = state; |
| 804 | } | ||
| 805 | 15618751 | } | |
| 806 | |||
| 807 | 5277 | void cache_state_rollback(my_off_t pos_to_rollback) { | |
| 808 |
2/2✓ Branch 0 taken 4199 times.
✓ Branch 1 taken 1078 times.
|
5277 | if (pos_to_rollback) { |
| 809 | 4199 | std::map<my_off_t, cache_state>::iterator it; | |
| 810 |
1/2✓ Branch 0 taken 4199 times.
✗ Branch 1 not taken.
|
4199 | it = cache_state_map.find(pos_to_rollback); |
| 811 |
1/2✓ Branch 0 taken 4199 times.
✗ Branch 1 not taken.
|
4199 | if (it != cache_state_map.end()) { |
| 812 | 4199 | flags.with_rbr = it->second.with_rbr; | |
| 813 | 4199 | flags.with_sbr = it->second.with_sbr; | |
| 814 | 4199 | flags.with_start = it->second.with_start; | |
| 815 | 4199 | flags.with_end = it->second.with_end; | |
| 816 | 4199 | flags.with_content = it->second.with_content; | |
| 817 | 4199 | event_counter = it->second.event_counter; | |
| 818 | } else | ||
| 819 | ✗ | assert(it == cache_state_map.end()); | |
| 820 | } | ||
| 821 | // Rolling back to pos == 0 means cleaning up the cache. | ||
| 822 | else { | ||
| 823 | 1078 | flags.with_rbr = false; | |
| 824 | 1078 | flags.with_sbr = false; | |
| 825 | 1078 | flags.with_start = false; | |
| 826 | 1078 | flags.with_end = false; | |
| 827 | 1078 | flags.with_content = false; | |
| 828 | 1078 | event_counter = 0; | |
| 829 | } | ||
| 830 | 5277 | } | |
| 831 | |||
| 832 | /** | ||
| 833 | Reset the cache to unused state when the transaction is finished. It | ||
| 834 | drops all data in the cache and clears the flags of the transaction state. | ||
| 835 | */ | ||
| 836 | 2596089 | virtual void reset() { | |
| 837 | 2596089 | compute_statistics(); | |
| 838 | 2596089 | remove_pending_event(); | |
| 839 | |||
| 840 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2596089 times.
|
2596089 | if (m_cache.reset()) { |
| 841 | ✗ | LogErr(WARNING_LEVEL, ER_BINLOG_CANT_RESIZE_CACHE); | |
| 842 | } | ||
| 843 | |||
| 844 | 2596089 | flags.incident = false; | |
| 845 | 2596089 | flags.with_xid = false; | |
| 846 | 2596089 | flags.immediate = false; | |
| 847 | 2596089 | flags.finalized = false; | |
| 848 | 2596089 | flags.with_sbr = false; | |
| 849 | 2596089 | flags.with_rbr = false; | |
| 850 | 2596089 | flags.with_start = false; | |
| 851 | 2596089 | flags.with_end = false; | |
| 852 | 2596089 | flags.with_content = false; | |
| 853 | |||
| 854 | /* | ||
| 855 | The truncate function calls reinit_io_cache that calls my_b_flush_io_cache | ||
| 856 | which may increase disk_writes. This breaks the disk_writes use by the | ||
| 857 | binary log which aims to compute the ratio between in-memory cache usage | ||
| 858 | and disk cache usage. To avoid this undesirable behavior, we reset the | ||
| 859 | variable after truncating the cache. | ||
| 860 | */ | ||
| 861 | 2596089 | cache_state_map.clear(); | |
| 862 | 2596089 | event_counter = 0; | |
| 863 | 2596089 | m_compressed_size = 0; | |
| 864 | 2596089 | m_decompressed_size = 0; | |
| 865 | 2596089 | m_compression_type = binary_log::transaction::compression::NONE; | |
| 866 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2596090 times.
|
2596089 | assert(is_binlog_empty()); |
| 867 | 2596090 | } | |
| 868 | |||
| 869 | /** | ||
| 870 | Returns information about the cache content with respect to | ||
| 871 | the binlog_format of the events. | ||
| 872 | |||
| 873 | This will be used to set a flag on GTID_LOG_EVENT stating that the | ||
| 874 | transaction may have SBR statements or not, but the binlog dump | ||
| 875 | will show this flag as "rbr_only" when it is not set. That's why | ||
| 876 | an empty transaction should return true below, or else an empty | ||
| 877 | transaction would be assumed as "rbr_only" even not having RBR | ||
| 878 | events. | ||
| 879 | |||
| 880 | When dumping a binary log content using mysqlbinlog client program, | ||
| 881 | for any transaction assumed as "rbr_only" it will be printed a | ||
| 882 | statement changing the transaction isolation level to READ COMMITTED. | ||
| 883 | It doesn't make sense to have an empty transaction "requiring" this | ||
| 884 | isolation level change. | ||
| 885 | |||
| 886 | @return true The cache have SBR events or is empty. | ||
| 887 | @return false The cache contains a transaction with no SBR events. | ||
| 888 | */ | ||
| 889 |
4/4✓ Branch 0 taken 1977516 times.
✓ Branch 1 taken 612781 times.
✓ Branch 2 taken 56331 times.
✓ Branch 3 taken 1921185 times.
|
2590297 | bool may_have_sbr_stmts() { return flags.with_sbr || !flags.with_rbr; } |
| 890 | |||
| 891 | /** | ||
| 892 | Check if the binlog cache contains an empty transaction, which has | ||
| 893 | two binlog events "BEGIN" and "COMMIT". | ||
| 894 | |||
| 895 | @return true The binlog cache contains an empty transaction. | ||
| 896 | @return false Otherwise. | ||
| 897 | */ | ||
| 898 | 884 | bool has_empty_transaction() { | |
| 899 | /* | ||
| 900 | The empty transaction has two events in trx/stmt binlog cache | ||
| 901 | and no changes: one is a transaction start and other is a transaction | ||
| 902 | end (there should be no SBR changing content and no RBR events). | ||
| 903 | */ | ||
| 904 |
2/2✓ Branch 0 taken 470 times.
✓ Branch 1 taken 414 times.
|
884 | if (flags.with_start && // Has transaction start statement |
| 905 |
1/2✓ Branch 0 taken 470 times.
✗ Branch 1 not taken.
|
470 | flags.with_end && // Has transaction end statement |
| 906 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 460 times.
|
470 | !flags.with_content) // Has no other content than START/END |
| 907 | { | ||
| 908 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | assert(event_counter == 2); // Two events in the cache only |
| 909 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | assert(!flags.with_sbr); // No statements changing content |
| 910 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | assert(!flags.with_rbr); // No rows changing content |
| 911 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | assert(!flags.immediate); // Not a DDL |
| 912 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | assert(!flags.with_xid); // Not a XID trx and not an atomic DDL Query |
| 913 | 10 | return true; | |
| 914 | } | ||
| 915 | 874 | return false; | |
| 916 | } | ||
| 917 | |||
| 918 | /** | ||
| 919 | Check if the binlog cache is empty or contains an empty transaction, | ||
| 920 | which has two binlog events "BEGIN" and "COMMIT". | ||
| 921 | |||
| 922 | @return true The binlog cache is empty or contains an empty transaction. | ||
| 923 | @return false Otherwise. | ||
| 924 | */ | ||
| 925 | 894 | bool is_empty_or_has_empty_transaction() { | |
| 926 |
4/4✓ Branch 0 taken 884 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 874 times.
|
894 | return is_binlog_empty() || has_empty_transaction(); |
| 927 | } | ||
| 928 | |||
| 929 | protected: | ||
| 930 | /* | ||
| 931 | This structure should have all cache variables/flags that should be restored | ||
| 932 | when a ROLLBACK TO SAVEPOINT statement be executed. | ||
| 933 | */ | ||
| 934 | struct cache_state { | ||
| 935 | bool with_sbr; | ||
| 936 | bool with_rbr; | ||
| 937 | bool with_start; | ||
| 938 | bool with_end; | ||
| 939 | bool with_content; | ||
| 940 | size_t event_counter; | ||
| 941 | }; | ||
| 942 | /* | ||
| 943 | For every SAVEPOINT used, we will store a cache_state for the current | ||
| 944 | binlog cache position. So, if a ROLLBACK TO SAVEPOINT is used, we can | ||
| 945 | restore the cache_state values after truncating the binlog cache. | ||
| 946 | */ | ||
| 947 | std::map<my_off_t, cache_state> cache_state_map; | ||
| 948 | /* | ||
| 949 | In order to compute the transaction size (because of possible extra checksum | ||
| 950 | bytes), we need to keep track of how many events are in the binlog cache. | ||
| 951 | */ | ||
| 952 | size_t event_counter = 0; | ||
| 953 | |||
| 954 | size_t m_compressed_size = 0; | ||
| 955 | size_t m_decompressed_size = 0; | ||
| 956 | binary_log::transaction::compression::type m_compression_type = | ||
| 957 | binary_log::transaction::compression::type::NONE; | ||
| 958 | /* | ||
| 959 | It truncates the cache to a certain position. This includes deleting the | ||
| 960 | pending event. It corresponds to rollback statement or rollback to | ||
| 961 | a savepoint. It doesn't change transaction state. | ||
| 962 | */ | ||
| 963 | 5277 | void truncate(my_off_t pos) { | |
| 964 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5277 times.
|
5277 | DBUG_PRINT("info", ("truncating to position %lu", (ulong)pos)); |
| 965 | 5277 | remove_pending_event(); | |
| 966 | |||
| 967 | // TODO: check the return value. | ||
| 968 | 5277 | (void)m_cache.truncate(pos); | |
| 969 | 5277 | } | |
| 970 | |||
| 971 | /** | ||
| 972 | Flush pending event to the cache buffer. | ||
| 973 | */ | ||
| 974 | 2590857 | int flush_pending_event(THD *thd) { | |
| 975 |
2/2✓ Branch 0 taken 22639 times.
✓ Branch 1 taken 2568218 times.
|
2590857 | if (m_pending) { |
| 976 | 22639 | m_pending->set_flags(Rows_log_event::STMT_END_F); | |
| 977 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22639 times.
|
22639 | if (int error = write_event(m_pending)) return error; |
| 978 | 22639 | thd->clear_binlog_table_maps(); | |
| 979 | } | ||
| 980 | 2590915 | return 0; | |
| 981 | } | ||
| 982 | |||
| 983 | /** | ||
| 984 | Remove the pending event. | ||
| 985 | */ | ||
| 986 | 2610309 | int remove_pending_event() { | |
| 987 |
2/2✓ Branch 0 taken 23934 times.
✓ Branch 1 taken 2586375 times.
|
2610309 | delete m_pending; |
| 988 | 2610310 | m_pending = nullptr; | |
| 989 | 2610310 | return 0; | |
| 990 | } | ||
| 991 | struct Flags { | ||
| 992 | /* | ||
| 993 | Defines if this is either a trx-cache or stmt-cache, respectively, a | ||
| 994 | transactional or non-transactional cache. | ||
| 995 | */ | ||
| 996 | bool transactional : 1; | ||
| 997 | |||
| 998 | /* | ||
| 999 | This indicates that some events did not get into the cache and most likely | ||
| 1000 | it is corrupted. | ||
| 1001 | */ | ||
| 1002 | bool incident : 1; | ||
| 1003 | |||
| 1004 | /* | ||
| 1005 | This indicates that the cache should be written without BEGIN/END. | ||
| 1006 | */ | ||
| 1007 | bool immediate : 1; | ||
| 1008 | |||
| 1009 | /* | ||
| 1010 | This flag indicates that the buffer was finalized and has to be | ||
| 1011 | flushed to disk. | ||
| 1012 | */ | ||
| 1013 | bool finalized : 1; | ||
| 1014 | |||
| 1015 | /* | ||
| 1016 | This indicates that either the cache contain an XID event, or it's | ||
| 1017 | an atomic DDL Query-log-event. In the latter case the flag is set up | ||
| 1018 | on the statement level, namely when the Query-log-event is cached | ||
| 1019 | at time the DDL transaction is not committing. | ||
| 1020 | The flag therefore gets reset when the cache is cleaned due to | ||
| 1021 | the statement rollback, e.g in case of a DDL post-caching execution | ||
| 1022 | error. | ||
| 1023 | Any statement scope flag among other things must consider its | ||
| 1024 | reset policy when the statement is rolled back. | ||
| 1025 | */ | ||
| 1026 | bool with_xid : 1; | ||
| 1027 | |||
| 1028 | /* | ||
| 1029 | This indicates that the cache contain statements changing content. | ||
| 1030 | */ | ||
| 1031 | bool with_sbr : 1; | ||
| 1032 | |||
| 1033 | /* | ||
| 1034 | This indicates that the cache contain RBR event changing content. | ||
| 1035 | */ | ||
| 1036 | bool with_rbr : 1; | ||
| 1037 | |||
| 1038 | /* | ||
| 1039 | This indicates that the cache contain s transaction start statement. | ||
| 1040 | */ | ||
| 1041 | bool with_start : 1; | ||
| 1042 | |||
| 1043 | /* | ||
| 1044 | This indicates that the cache contain a transaction end event. | ||
| 1045 | */ | ||
| 1046 | bool with_end : 1; | ||
| 1047 | |||
| 1048 | /* | ||
| 1049 | This indicates that the cache contain content other than START/END. | ||
| 1050 | */ | ||
| 1051 | bool with_content : 1; | ||
| 1052 | } flags; | ||
| 1053 | |||
| 1054 | virtual bool compress(THD *); | ||
| 1055 | |||
| 1056 | private: | ||
| 1057 | /* | ||
| 1058 | Storage for byte data. This binlog_cache_data will serialize | ||
| 1059 | events into bytes and put them into m_cache. | ||
| 1060 | */ | ||
| 1061 | Binlog_cache_storage m_cache; | ||
| 1062 | |||
| 1063 | /* | ||
| 1064 | Pending binrows event. This event is the event where the rows are currently | ||
| 1065 | written. | ||
| 1066 | */ | ||
| 1067 | Rows_log_event *m_pending; | ||
| 1068 | |||
| 1069 | /** | ||
| 1070 | This function computes binlog cache and disk usage. | ||
| 1071 | */ | ||
| 1072 | 2596089 | void compute_statistics() { | |
| 1073 | #ifdef WITH_WSREP | ||
| 1074 |
2/2✓ Branch 0 taken 308 times.
✓ Branch 1 taken 2595781 times.
|
2596089 | if (wsrep_emulate_bin_log) return; |
| 1075 | #endif /* WITH_WSREP */ | ||
| 1076 |
2/2✓ Branch 0 taken 2595454 times.
✓ Branch 1 taken 328 times.
|
2595781 | if (!is_binlog_empty()) { |
| 1077 | 2595454 | (*ptr_binlog_cache_use)++; | |
| 1078 |
2/2✓ Branch 0 taken 53536 times.
✓ Branch 1 taken 2541917 times.
|
2595454 | if (m_cache.disk_writes() != 0) (*ptr_binlog_cache_disk_use)++; |
| 1079 | } | ||
| 1080 | } | ||
| 1081 | |||
| 1082 | /* | ||
| 1083 | Stores a pointer to the status variable that keeps track of the in-memory | ||
| 1084 | cache usage. This corresponds to either | ||
| 1085 | . binlog_cache_use or binlog_stmt_cache_use. | ||
| 1086 | */ | ||
| 1087 | ulong *ptr_binlog_cache_use; | ||
| 1088 | |||
| 1089 | /* | ||
| 1090 | Stores a pointer to the status variable that keeps track of the disk | ||
| 1091 | cache usage. This corresponds to either | ||
| 1092 | . binlog_cache_disk_use or binlog_stmt_cache_disk_use. | ||
| 1093 | */ | ||
| 1094 | ulong *ptr_binlog_cache_disk_use; | ||
| 1095 | |||
| 1096 | binlog_cache_data &operator=(const binlog_cache_data &info); | ||
| 1097 | binlog_cache_data(const binlog_cache_data &info); | ||
| 1098 | }; | ||
| 1099 | |||
| 1100 | class binlog_stmt_cache_data : public binlog_cache_data { | ||
| 1101 | public: | ||
| 1102 | 42029 | binlog_stmt_cache_data(bool trx_cache_arg, ulong *ptr_binlog_cache_use_arg, | |
| 1103 | ulong *ptr_binlog_cache_disk_use_arg) | ||
| 1104 | 42029 | : binlog_cache_data(trx_cache_arg, ptr_binlog_cache_use_arg, | |
| 1105 | 42029 | ptr_binlog_cache_disk_use_arg) {} | |
| 1106 | |||
| 1107 | using binlog_cache_data::finalize; | ||
| 1108 | |||
| 1109 | int finalize(THD *thd); | ||
| 1110 | }; | ||
| 1111 | |||
| 1112 | 489853 | int binlog_stmt_cache_data::finalize(THD *thd) { | |
| 1113 |
2/2✓ Branch 0 taken 91289 times.
✓ Branch 1 taken 398564 times.
|
489853 | if (flags.immediate) { |
| 1114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 91290 times.
|
91289 | if (int error = finalize(thd, nullptr)) return error; |
| 1115 | } else { | ||
| 1116 | Query_log_event end_evt(thd, STRING_WITH_LEN("COMMIT"), false, false, true, | ||
| 1117 |
1/2✓ Branch 0 taken 398815 times.
✗ Branch 1 not taken.
|
398564 | 0, true); |
| 1118 |
2/4✓ Branch 0 taken 398835 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 398835 times.
|
398815 | if (int error = finalize(thd, &end_evt)) return error; |
| 1119 |
1/2✓ Branch 0 taken 398827 times.
✗ Branch 1 not taken.
|
398835 | } |
| 1120 | 490117 | return 0; | |
| 1121 | } | ||
| 1122 | |||
| 1123 | class binlog_trx_cache_data : public binlog_cache_data { | ||
| 1124 | public: | ||
| 1125 | 42029 | binlog_trx_cache_data(bool trx_cache_arg, ulong *ptr_binlog_cache_use_arg, | |
| 1126 | ulong *ptr_binlog_cache_disk_use_arg) | ||
| 1127 | 42029 | : binlog_cache_data(trx_cache_arg, ptr_binlog_cache_use_arg, | |
| 1128 | ptr_binlog_cache_disk_use_arg), | ||
| 1129 | 42029 | m_cannot_rollback(false), | |
| 1130 | 42029 | before_stmt_pos(MY_OFF_T_UNDEF) {} | |
| 1131 | |||
| 1132 | 2105863 | void reset() override { | |
| 1133 |
1/2✓ Branch 0 taken 2105864 times.
✗ Branch 1 not taken.
|
2105863 | DBUG_TRACE; |
| 1134 |
5/8✓ Branch 0 taken 2105864 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2105864 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 84 times.
✓ Branch 5 taken 2105780 times.
✓ Branch 6 taken 84 times.
✗ Branch 7 not taken.
|
2105864 | DBUG_PRINT("enter", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos)); |
| 1135 | 2105864 | m_cannot_rollback = false; | |
| 1136 | 2105864 | before_stmt_pos = MY_OFF_T_UNDEF; | |
| 1137 |
1/2✓ Branch 0 taken 2105864 times.
✗ Branch 1 not taken.
|
2105864 | binlog_cache_data::reset(); |
| 1138 |
5/8✓ Branch 0 taken 2105864 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2105864 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 84 times.
✓ Branch 5 taken 2105780 times.
✓ Branch 6 taken 84 times.
✗ Branch 7 not taken.
|
2105864 | DBUG_PRINT("return", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos)); |
| 1139 | 4211728 | return; | |
| 1140 | 2105864 | } | |
| 1141 | |||
| 1142 | 13274 | bool cannot_rollback() const { return m_cannot_rollback; } | |
| 1143 | |||
| 1144 | 1184 | void set_cannot_rollback() { m_cannot_rollback = true; } | |
| 1145 | |||
| 1146 | 4906875 | my_off_t get_prev_position() const { return before_stmt_pos; } | |
| 1147 | |||
| 1148 | 10758446 | void set_prev_position(my_off_t pos) { | |
| 1149 |
1/2✓ Branch 0 taken 10759046 times.
✗ Branch 1 not taken.
|
10758446 | DBUG_TRACE; |
| 1150 |
5/8✓ Branch 0 taken 10758938 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10758927 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 242 times.
✓ Branch 5 taken 10758685 times.
✓ Branch 6 taken 242 times.
✗ Branch 7 not taken.
|
10759046 | DBUG_PRINT("enter", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos)); |
| 1151 | 10758927 | before_stmt_pos = pos; | |
| 1152 |
1/2✓ Branch 0 taken 10758864 times.
✗ Branch 1 not taken.
|
10758927 | cache_state_checkpoint(before_stmt_pos); |
| 1153 |
5/8✓ Branch 0 taken 10758516 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10758767 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 242 times.
✓ Branch 5 taken 10758525 times.
✓ Branch 6 taken 246 times.
✗ Branch 7 not taken.
|
10758864 | DBUG_PRINT("return", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos)); |
| 1154 | 21517844 | return; | |
| 1155 | 10758771 | } | |
| 1156 | |||
| 1157 | 1242 | void restore_prev_position() { | |
| 1158 |
1/2✓ Branch 0 taken 1242 times.
✗ Branch 1 not taken.
|
1242 | DBUG_TRACE; |
| 1159 |
3/8✓ Branch 0 taken 1242 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1242 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1242 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
1242 | DBUG_PRINT("enter", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos)); |
| 1160 |
1/2✓ Branch 0 taken 1242 times.
✗ Branch 1 not taken.
|
1242 | binlog_cache_data::truncate(before_stmt_pos); |
| 1161 |
1/2✓ Branch 0 taken 1242 times.
✗ Branch 1 not taken.
|
1242 | cache_state_rollback(before_stmt_pos); |
| 1162 | 1242 | before_stmt_pos = MY_OFF_T_UNDEF; | |
| 1163 | /* | ||
| 1164 | Binlog statement rollback clears with_xid now as the atomic DDL statement | ||
| 1165 | marker which can be set as early as at event creation and caching. | ||
| 1166 | */ | ||
| 1167 | 1242 | flags.with_xid = false; | |
| 1168 |
3/8✓ Branch 0 taken 1242 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1242 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1242 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
1242 | DBUG_PRINT("return", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos)); |
| 1169 | 2484 | return; | |
| 1170 | 1242 | } | |
| 1171 | |||
| 1172 | 4035 | void restore_savepoint(my_off_t pos) { | |
| 1173 |
1/2✓ Branch 0 taken 4035 times.
✗ Branch 1 not taken.
|
4035 | DBUG_TRACE; |
| 1174 |
3/8✓ Branch 0 taken 4035 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4035 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4035 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
4035 | DBUG_PRINT("enter", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos)); |
| 1175 |
1/2✓ Branch 0 taken 4035 times.
✗ Branch 1 not taken.
|
4035 | binlog_cache_data::truncate(pos); |
| 1176 |
2/2✓ Branch 0 taken 4019 times.
✓ Branch 1 taken 16 times.
|
4035 | if (pos <= before_stmt_pos) before_stmt_pos = MY_OFF_T_UNDEF; |
| 1177 |
1/2✓ Branch 0 taken 4035 times.
✗ Branch 1 not taken.
|
4035 | cache_state_rollback(pos); |
| 1178 |
3/8✓ Branch 0 taken 4035 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4035 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4035 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
4035 | DBUG_PRINT("return", ("before_stmt_pos: %llu", (ulonglong)before_stmt_pos)); |
| 1179 | 8070 | return; | |
| 1180 | 4035 | } | |
| 1181 | |||
| 1182 | using binlog_cache_data::truncate; | ||
| 1183 | |||
| 1184 | int truncate(THD *thd, bool all); | ||
| 1185 | |||
| 1186 | private: | ||
| 1187 | /* | ||
| 1188 | It will be set true if any statement which cannot be rolled back safely | ||
| 1189 | is put in trx_cache. | ||
| 1190 | */ | ||
| 1191 | bool m_cannot_rollback; | ||
| 1192 | |||
| 1193 | /* | ||
| 1194 | Binlog position before the start of the current statement. | ||
| 1195 | */ | ||
| 1196 | my_off_t before_stmt_pos; | ||
| 1197 | |||
| 1198 | binlog_trx_cache_data &operator=(const binlog_trx_cache_data &info); | ||
| 1199 | binlog_trx_cache_data(const binlog_trx_cache_data &info); | ||
| 1200 | }; | ||
| 1201 | |||
| 1202 | class binlog_cache_mngr { | ||
| 1203 | public: | ||
| 1204 | 42029 | binlog_cache_mngr(ulong *ptr_binlog_stmt_cache_use_arg, | |
| 1205 | ulong *ptr_binlog_stmt_cache_disk_use_arg, | ||
| 1206 | ulong *ptr_binlog_cache_use_arg, | ||
| 1207 | ulong *ptr_binlog_cache_disk_use_arg) | ||
| 1208 | 42029 | : stmt_cache(false, ptr_binlog_stmt_cache_use_arg, | |
| 1209 | ptr_binlog_stmt_cache_disk_use_arg), | ||
| 1210 |
1/2✓ Branch 0 taken 42029 times.
✗ Branch 1 not taken.
|
42029 | trx_cache(true, ptr_binlog_cache_use_arg, |
| 1211 | 42029 | ptr_binlog_cache_disk_use_arg) {} | |
| 1212 | |||
| 1213 | 42027 | bool init() { | |
| 1214 | 42027 | return stmt_cache.open(binlog_stmt_cache_size, | |
| 1215 |
1/2✓ Branch 0 taken 42029 times.
✗ Branch 1 not taken.
|
84058 | max_binlog_stmt_cache_size) || |
| 1216 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42029 times.
|
84058 | trx_cache.open(binlog_cache_size, max_binlog_cache_size); |
| 1217 | } | ||
| 1218 | |||
| 1219 | 89656105 | binlog_cache_data *get_binlog_cache_data(bool is_transactional) { | |
| 1220 |
2/2✓ Branch 0 taken 76558748 times.
✓ Branch 1 taken 13097357 times.
|
89656105 | if (is_transactional) |
| 1221 | 76558748 | return &trx_cache; | |
| 1222 | else | ||
| 1223 | 13097357 | return &stmt_cache; | |
| 1224 | } | ||
| 1225 | |||
| 1226 | 103745 | Binlog_cache_storage *get_stmt_cache() { return stmt_cache.get_cache(); } | |
| 1227 | 1069349 | Binlog_cache_storage *get_trx_cache() { return trx_cache.get_cache(); } | |
| 1228 | /** | ||
| 1229 | Convenience method to check if both caches are empty. | ||
| 1230 | */ | ||
| 1231 | 310112 | bool is_binlog_empty() const { | |
| 1232 |
4/4✓ Branch 0 taken 309383 times.
✓ Branch 1 taken 834 times.
✓ Branch 2 taken 300591 times.
✓ Branch 3 taken 8795 times.
|
310112 | return stmt_cache.is_binlog_empty() && trx_cache.is_binlog_empty(); |
| 1233 | } | ||
| 1234 | |||
| 1235 | /* | ||
| 1236 | clear stmt_cache and trx_cache if they are not empty | ||
| 1237 | */ | ||
| 1238 | 912 | void reset() { | |
| 1239 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 910 times.
|
912 | if (!stmt_cache.is_binlog_empty()) stmt_cache.reset(); |
| 1240 |
2/2✓ Branch 0 taken 896 times.
✓ Branch 1 taken 16 times.
|
912 | if (!trx_cache.is_binlog_empty()) trx_cache.reset(); |
| 1241 | 912 | } | |
| 1242 | |||
| 1243 | #ifndef NDEBUG | ||
| 1244 | 2697198 | bool dbug_any_finalized() const { | |
| 1245 |
3/4✓ Branch 0 taken 2697408 times.
✓ Branch 1 taken 45 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2697175 times.
|
2697198 | return stmt_cache.is_finalized() || trx_cache.is_finalized(); |
| 1246 | } | ||
| 1247 | #endif | ||
| 1248 | |||
| 1249 | /* | ||
| 1250 | Convenience method to flush both caches to the binary log. | ||
| 1251 | |||
| 1252 | @param bytes_written Pointer to variable that will be set to the | ||
| 1253 | number of bytes written for the flush. | ||
| 1254 | @param wrote_xid Pointer to variable that will be set to @c | ||
| 1255 | true if any XID event was written to the | ||
| 1256 | binary log. Otherwise, the variable will not | ||
| 1257 | be touched. | ||
| 1258 | @return Error code on error, zero if no error. | ||
| 1259 | */ | ||
| 1260 | 2585324 | int flush(THD *thd, my_off_t *bytes_written, bool *wrote_xid) { | |
| 1261 | 2585324 | my_off_t stmt_bytes = 0; | |
| 1262 | 2585324 | my_off_t trx_bytes = 0; | |
| 1263 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2585324 times.
|
2585324 | assert(stmt_cache.has_xid() == 0); |
| 1264 |
1/2✓ Branch 0 taken 2585323 times.
✗ Branch 1 not taken.
|
2585324 | int error = stmt_cache.flush(thd, &stmt_bytes, wrote_xid); |
| 1265 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2585322 times.
|
2585323 | if (error) return error; |
| 1266 |
3/4✓ Branch 0 taken 2584042 times.
✓ Branch 1 taken 1280 times.
✓ Branch 2 taken 2584042 times.
✗ Branch 3 not taken.
|
2585322 | DEBUG_SYNC(thd, "after_flush_stm_cache_before_flush_trx_cache"); |
| 1267 |
1/2✓ Branch 0 taken 2585320 times.
✗ Branch 1 not taken.
|
2585322 | error = trx_cache.flush(thd, &trx_bytes, wrote_xid); |
| 1268 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2585317 times.
|
2585320 | if (error) return error; |
| 1269 | 2585317 | *bytes_written = stmt_bytes + trx_bytes; | |
| 1270 | 2585317 | return 0; | |
| 1271 | } | ||
| 1272 | |||
| 1273 | /** | ||
| 1274 | Check if at least one of transactions and statement binlog caches | ||
| 1275 | contains an empty transaction, other one is empty or contains an | ||
| 1276 | empty transaction. | ||
| 1277 | |||
| 1278 | @return true At least one of transactions and statement binlog | ||
| 1279 | caches an empty transaction, other one is empty | ||
| 1280 | or contains an empty transaction. | ||
| 1281 | @return false Otherwise. | ||
| 1282 | */ | ||
| 1283 | 884 | bool has_empty_transaction() { | |
| 1284 | 884 | return (trx_cache.is_empty_or_has_empty_transaction() && | |
| 1285 |
3/4✓ Branch 0 taken 10 times.
✓ Branch 1 taken 874 times.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
|
894 | stmt_cache.is_empty_or_has_empty_transaction() && |
| 1286 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
894 | !is_binlog_empty()); |
| 1287 | } | ||
| 1288 | |||
| 1289 | /** | ||
| 1290 | Check if manager contains consistent snapshot of log coordinates | ||
| 1291 | and gtid_executed. | ||
| 1292 | |||
| 1293 | @return true Consistent snapshot available | ||
| 1294 | @return false Otherwise | ||
| 1295 | */ | ||
| 1296 | 39058 | bool has_consistent_snapshot() const { | |
| 1297 | /** | ||
| 1298 | snapshot_gtid_executed can be empty string | ||
| 1299 | if gtid_mode=OFF. | ||
| 1300 | */ | ||
| 1301 | |||
| 1302 | 39058 | return binlog_info.log_file_name[0] != '\0'; | |
| 1303 | } | ||
| 1304 | |||
| 1305 | /** | ||
| 1306 | Removes consistent snapshot from cache. | ||
| 1307 | */ | ||
| 1308 | 2260523 | void drop_consistent_snapshot() { | |
| 1309 | 2260523 | binlog_info.log_file_name[0] = '\0'; | |
| 1310 | 2260523 | snapshot_gtid_executed.clear(); | |
| 1311 | 2260719 | } | |
| 1312 | |||
| 1313 | binlog_stmt_cache_data stmt_cache; | ||
| 1314 | binlog_trx_cache_data trx_cache; | ||
| 1315 | |||
| 1316 | LOG_INFO binlog_info; | ||
| 1317 | std::string snapshot_gtid_executed; | ||
| 1318 | |||
| 1319 | private: | ||
| 1320 | binlog_cache_mngr &operator=(const binlog_cache_mngr &info); | ||
| 1321 | binlog_cache_mngr(const binlog_cache_mngr &info); | ||
| 1322 | }; | ||
| 1323 | |||
| 1324 | 191516325 | static binlog_cache_mngr *thd_get_cache_mngr(const THD *thd) { | |
| 1325 | /* | ||
| 1326 | If opt_bin_log is not set, binlog_hton->slot == -1 and hence | ||
| 1327 | thd_get_ha_data(thd, hton) segfaults. | ||
| 1328 | */ | ||
| 1329 | #ifdef WITH_WSREP | ||
| 1330 | /* PXC can operate in emulation bin logging mode so suppressing the check. */ | ||
| 1331 | #else | ||
| 1332 | assert(opt_bin_log); | ||
| 1333 | #endif /* WITH_WSREP */ | ||
| 1334 | 191516325 | return (binlog_cache_mngr *)thd_get_ha_data(thd, binlog_hton); | |
| 1335 | } | ||
| 1336 | |||
| 1337 | /** | ||
| 1338 | Checks if the BINLOG_CACHE_SIZE's value is greater than MAX_BINLOG_CACHE_SIZE. | ||
| 1339 | If this happens, the BINLOG_CACHE_SIZE is set to MAX_BINLOG_CACHE_SIZE. | ||
| 1340 | */ | ||
| 1341 | 9488 | void check_binlog_cache_size(THD *thd) { | |
| 1342 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 9474 times.
|
9488 | if (binlog_cache_size > max_binlog_cache_size) { |
| 1343 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 2 times.
|
14 | if (thd) { |
| 1344 | 12 | push_warning_printf( | |
| 1345 | thd, Sql_condition::SL_WARNING, ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX, | ||
| 1346 | ER_THD(thd, ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX), | ||
| 1347 | (ulong)binlog_cache_size, (ulong)max_binlog_cache_size); | ||
| 1348 | } else { | ||
| 1349 |
7/14✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 2 times.
✗ Branch 13 not taken.
|
2 | LogErr(WARNING_LEVEL, ER_BINLOG_CACHE_SIZE_TOO_LARGE, binlog_cache_size, |
| 1350 | (ulong)max_binlog_cache_size); | ||
| 1351 | } | ||
| 1352 | 14 | binlog_cache_size = static_cast<ulong>(max_binlog_cache_size); | |
| 1353 | } | ||
| 1354 | 9488 | } | |
| 1355 | |||
| 1356 | /** | ||
| 1357 | Checks if the BINLOG_STMT_CACHE_SIZE's value is greater than | ||
| 1358 | MAX_BINLOG_STMT_CACHE_SIZE. If this happens, the BINLOG_STMT_CACHE_SIZE is set | ||
| 1359 | to MAX_BINLOG_STMT_CACHE_SIZE. | ||
| 1360 | */ | ||
| 1361 | 9464 | void check_binlog_stmt_cache_size(THD *thd) { | |
| 1362 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9455 times.
|
9464 | if (binlog_stmt_cache_size > max_binlog_stmt_cache_size) { |
| 1363 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | if (thd) { |
| 1364 | 9 | push_warning_printf( | |
| 1365 | thd, Sql_condition::SL_WARNING, | ||
| 1366 | ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX, | ||
| 1367 | ER_THD(thd, ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX), | ||
| 1368 | (ulong)binlog_stmt_cache_size, (ulong)max_binlog_stmt_cache_size); | ||
| 1369 | } else { | ||
| 1370 | ✗ | LogErr(WARNING_LEVEL, ER_BINLOG_STMT_CACHE_SIZE_TOO_LARGE, | |
| 1371 | binlog_stmt_cache_size, (ulong)max_binlog_stmt_cache_size); | ||
| 1372 | } | ||
| 1373 | 9 | binlog_stmt_cache_size = static_cast<ulong>(max_binlog_stmt_cache_size); | |
| 1374 | } | ||
| 1375 | 9464 | } | |
| 1376 | |||
| 1377 | /** | ||
| 1378 | Check whether binlog_hton has valid slot and enabled | ||
| 1379 | */ | ||
| 1380 | ✗ | bool binlog_enabled() { | |
| 1381 | ✗ | return (binlog_hton && binlog_hton->slot != HA_SLOT_UNDEF); | |
| 1382 | } | ||
| 1383 | |||
| 1384 | /* | ||
| 1385 | Save position of binary log transaction cache. | ||
| 1386 | |||
| 1387 | SYNPOSIS | ||
| 1388 | binlog_trans_log_savepos() | ||
| 1389 | |||
| 1390 | thd The thread to take the binlog data from | ||
| 1391 | pos Pointer to variable where the position will be stored | ||
| 1392 | |||
| 1393 | DESCRIPTION | ||
| 1394 | |||
| 1395 | Save the current position in the binary log transaction cache into | ||
| 1396 | the variable pointed to by 'pos' | ||
| 1397 | */ | ||
| 1398 | |||
| 1399 | 4859783 | static void binlog_trans_log_savepos(THD *thd, my_off_t *pos) { | |
| 1400 |
1/2✓ Branch 0 taken 4860223 times.
✗ Branch 1 not taken.
|
4859783 | DBUG_TRACE; |
| 1401 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4860223 times.
|
4860223 | assert(pos != nullptr); |
| 1402 |
1/2✓ Branch 0 taken 4860328 times.
✗ Branch 1 not taken.
|
4860223 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); |
| 1403 | |||
| 1404 | #ifdef WITH_WSREP | ||
| 1405 |
10/12✓ Branch 0 taken 4860330 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 87944 times.
✓ Branch 3 taken 4772386 times.
✓ Branch 4 taken 87930 times.
✓ Branch 5 taken 14 times.
✓ Branch 6 taken 87877 times.
✓ Branch 7 taken 53 times.
✓ Branch 8 taken 59 times.
✓ Branch 9 taken 87818 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 4860099 times.
|
4860328 | assert((WSREP_EMULATE_BINLOG(thd)) || mysql_bin_log.is_open()); |
| 1406 | #else | ||
| 1407 | assert(mysql_bin_log.is_open()); | ||
| 1408 | #endif /* WITH_WSREP */ | ||
| 1409 | |||
| 1410 |
1/2✓ Branch 0 taken 4860023 times.
✗ Branch 1 not taken.
|
4860158 | *pos = cache_mngr->trx_cache.get_byte_position(); |
| 1411 |
5/8✓ Branch 0 taken 4859926 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4860008 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 95 times.
✓ Branch 5 taken 4859913 times.
✓ Branch 6 taken 95 times.
✗ Branch 7 not taken.
|
4860023 | DBUG_PRINT("return", ("position: %lu", (ulong)*pos)); |
| 1412 |
1/2✓ Branch 0 taken 4859968 times.
✗ Branch 1 not taken.
|
4860008 | cache_mngr->trx_cache.cache_state_checkpoint(*pos); |
| 1413 | 4859968 | } | |
| 1414 | |||
| 1415 | 9292 | static int binlog_dummy_recover(handlerton *, XA_recover_txn *, uint, | |
| 1416 | MEM_ROOT *) { | ||
| 1417 | 9292 | return 0; | |
| 1418 | } | ||
| 1419 | |||
| 1420 | /** | ||
| 1421 | Auxiliary class to copy serialized events to the binary log and | ||
| 1422 | correct some of the fields that are not known until just before | ||
| 1423 | writing the event. | ||
| 1424 | |||
| 1425 | This class allows feeding events in parts, so it is practical to use | ||
| 1426 | in do_write_cache() which reads events from an IO_CACHE where events | ||
| 1427 | may span multiple cache pages. | ||
| 1428 | |||
| 1429 | The following fields are fixed before writing the event: | ||
| 1430 | - end_log_pos is set | ||
| 1431 | - the checksum is computed if checksums are enabled | ||
| 1432 | - the length is incremented by the checksum size if checksums are enabled | ||
| 1433 | */ | ||
| 1434 | class Binlog_event_writer : public Basic_ostream { | ||
| 1435 | MYSQL_BIN_LOG::Binlog_ofile *m_binlog_file; | ||
| 1436 | bool have_checksum; | ||
| 1437 | ha_checksum initial_checksum; | ||
| 1438 | ha_checksum checksum; | ||
| 1439 | uint32 end_log_pos; | ||
| 1440 | THD *thd; | ||
| 1441 | uchar header[LOG_EVENT_HEADER_LEN]; | ||
| 1442 | my_off_t header_len = 0; | ||
| 1443 | uint32 event_len = 0; | ||
| 1444 | |||
| 1445 | public: | ||
| 1446 | /** | ||
| 1447 | Constructs a new Binlog_event_writer. Should be called once before | ||
| 1448 | starting to flush the transaction or statement cache to the | ||
| 1449 | binlog. | ||
| 1450 | |||
| 1451 | @param binlog_file to write to. | ||
| 1452 | @param thd_arg THD to account written binlog byte statistics to | ||
| 1453 | */ | ||
| 1454 | 2590143 | Binlog_event_writer(MYSQL_BIN_LOG::Binlog_ofile *binlog_file, THD *thd_arg) | |
| 1455 | 5180286 | : m_binlog_file(binlog_file), | |
| 1456 | 2590143 | have_checksum(binlog_checksum_options != | |
| 1457 | binary_log::BINLOG_CHECKSUM_ALG_OFF), | ||
| 1458 | 5180286 | initial_checksum(my_checksum(0L, nullptr, 0)), | |
| 1459 | 2590143 | checksum(initial_checksum), | |
| 1460 | 2590143 | end_log_pos(binlog_file->position()), | |
| 1461 |
1/2✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
|
2590143 | thd(thd_arg) { |
| 1462 | // Simulate checksum error | ||
| 1463 |
3/4✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2590142 times.
|
2590143 | if (DBUG_EVALUATE_IF("fault_injection_crc_value", 1, 0)) checksum--; |
| 1464 | 2590143 | } | |
| 1465 | |||
| 1466 | 16491695 | void update_header() { | |
| 1467 | 16491695 | event_len = uint4korr(header + EVENT_LEN_OFFSET); | |
| 1468 | |||
| 1469 | // Increase end_log_pos | ||
| 1470 | 16491695 | end_log_pos += event_len; | |
| 1471 | |||
| 1472 | // Update event length if it has checksum | ||
| 1473 |
2/2✓ Branch 0 taken 16490958 times.
✓ Branch 1 taken 737 times.
|
16491695 | if (have_checksum) { |
| 1474 | 16490958 | int4store(header + EVENT_LEN_OFFSET, event_len + BINLOG_CHECKSUM_LEN); | |
| 1475 | 16490958 | end_log_pos += BINLOG_CHECKSUM_LEN; | |
| 1476 | } | ||
| 1477 | |||
| 1478 | // Store end_log_pos | ||
| 1479 | 16491695 | int4store(header + LOG_POS_OFFSET, end_log_pos); | |
| 1480 | // update the checksum | ||
| 1481 |
2/2✓ Branch 0 taken 16490958 times.
✓ Branch 1 taken 737 times.
|
16491695 | if (have_checksum) checksum = my_checksum(checksum, header, header_len); |
| 1482 | 16491695 | } | |
| 1483 | |||
| 1484 | 11144778 | bool write(const unsigned char *buffer, my_off_t length) override { | |
| 1485 |
1/2✓ Branch 0 taken 11144778 times.
✗ Branch 1 not taken.
|
11144778 | DBUG_TRACE; |
| 1486 | |||
| 1487 |
2/2✓ Branch 0 taken 36357669 times.
✓ Branch 1 taken 11144778 times.
|
47502447 | while (length > 0) { |
| 1488 | /* Write event header into binlog */ | ||
| 1489 |
2/2✓ Branch 0 taken 16494507 times.
✓ Branch 1 taken 19863162 times.
|
36357669 | if (event_len == 0) { |
| 1490 | /* data in the buf may be smaller than header size.*/ | ||
| 1491 | uint32 header_incr = | ||
| 1492 | 16494507 | std::min<uint32>(LOG_EVENT_HEADER_LEN - header_len, length); | |
| 1493 | |||
| 1494 | 16494507 | memcpy(header + header_len, buffer, header_incr); | |
| 1495 | 16494507 | header_len += header_incr; | |
| 1496 | 16494507 | buffer += header_incr; | |
| 1497 | 16494507 | length -= header_incr; | |
| 1498 | |||
| 1499 |
2/2✓ Branch 0 taken 16491695 times.
✓ Branch 1 taken 2812 times.
|
16494507 | if (header_len == LOG_EVENT_HEADER_LEN) { |
| 1500 |
1/2✓ Branch 0 taken 16491695 times.
✗ Branch 1 not taken.
|
16491695 | update_header(); |
| 1501 |
2/4✓ Branch 0 taken 16491695 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16491695 times.
|
16491695 | if (m_binlog_file->write(header, header_len)) return true; |
| 1502 | |||
| 1503 | 16491695 | event_len -= header_len; | |
| 1504 | 16491695 | header_len = 0; | |
| 1505 | } | ||
| 1506 | } else { | ||
| 1507 | 19863162 | my_off_t write_bytes = std::min<uint64>(length, event_len); | |
| 1508 | |||
| 1509 |
2/4✓ Branch 0 taken 19863162 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19863162 times.
|
19863162 | if (m_binlog_file->write(buffer, write_bytes)) return true; |
| 1510 | |||
| 1511 | // update the checksum | ||
| 1512 |
2/2✓ Branch 0 taken 19862212 times.
✓ Branch 1 taken 950 times.
|
19863162 | if (have_checksum) |
| 1513 |
1/2✓ Branch 0 taken 19862212 times.
✗ Branch 1 not taken.
|
19862212 | checksum = my_checksum(checksum, buffer, write_bytes); |
| 1514 | |||
| 1515 | 19863162 | event_len -= write_bytes; | |
| 1516 | 19863162 | length -= write_bytes; | |
| 1517 | 19863162 | buffer += write_bytes; | |
| 1518 | |||
| 1519 | // The whole event is copied, now add the checksum | ||
| 1520 |
4/4✓ Branch 0 taken 19862212 times.
✓ Branch 1 taken 950 times.
✓ Branch 2 taken 16490958 times.
✓ Branch 3 taken 3371254 times.
|
19863162 | if (have_checksum && event_len == 0) { |
| 1521 | uchar checksum_buf[BINLOG_CHECKSUM_LEN]; | ||
| 1522 | |||
| 1523 | 16490958 | int4store(checksum_buf, checksum); | |
| 1524 |
2/4✓ Branch 0 taken 16490958 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16490958 times.
|
16490958 | if (m_binlog_file->write(checksum_buf, BINLOG_CHECKSUM_LEN)) |
| 1525 | ✗ | return true; | |
| 1526 | 16490958 | checksum = initial_checksum; | |
| 1527 | } | ||
| 1528 | } | ||
| 1529 | } | ||
| 1530 | 11144778 | return false; | |
| 1531 | 11144778 | } | |
| 1532 | /** | ||
| 1533 | Returns true if per event checksum is enabled. | ||
| 1534 | */ | ||
| 1535 | 2590253 | bool is_checksum_enabled() { return have_checksum; } | |
| 1536 | }; | ||
| 1537 | |||
| 1538 | /* | ||
| 1539 | this function is mostly a placeholder. | ||
| 1540 | conceptually, binlog initialization (now mostly done in MYSQL_BIN_LOG::open) | ||
| 1541 | should be moved here. | ||
| 1542 | */ | ||
| 1543 | |||
| 1544 | 9606 | static int binlog_init(void *p) { | |
| 1545 | 9606 | binlog_hton = (handlerton *)p; | |
| 1546 | |||
| 1547 | #ifdef WITH_WSREP | ||
| 1548 | /* | ||
| 1549 | During bootstrap (seed-db creation), wsrep options may not be configured | ||
| 1550 | which will then disable binlog_hton but other WSREP compiled checks needs | ||
| 1551 | binlog_hton, so enable it while operating in bootstrap mode too. | ||
| 1552 | */ | ||
| 1553 |
6/6✓ Branch 0 taken 9404 times.
✓ Branch 1 taken 202 times.
✓ Branch 2 taken 8952 times.
✓ Branch 3 taken 452 times.
✓ Branch 4 taken 202 times.
✓ Branch 5 taken 8952 times.
|
9606 | if (WSREP_ON || opt_initialize) |
| 1554 | 654 | binlog_hton->state = SHOW_OPTION_YES; | |
| 1555 | else | ||
| 1556 |
2/2✓ Branch 0 taken 8700 times.
✓ Branch 1 taken 252 times.
|
8952 | binlog_hton->state = opt_bin_log ? SHOW_OPTION_YES : SHOW_OPTION_NO; |
| 1557 | #else | ||
| 1558 | binlog_hton->state = opt_bin_log ? SHOW_OPTION_YES : SHOW_OPTION_NO; | ||
| 1559 | #endif /* WITH_WSREP */ | ||
| 1560 | |||
| 1561 | 9606 | binlog_hton->db_type = DB_TYPE_BINLOG; | |
| 1562 | 9606 | binlog_hton->savepoint_offset = sizeof(my_off_t); | |
| 1563 | 9606 | binlog_hton->close_connection = binlog_close_connection; | |
| 1564 | 9606 | binlog_hton->savepoint_set = binlog_savepoint_set; | |
| 1565 | 9606 | binlog_hton->savepoint_rollback = binlog_savepoint_rollback; | |
| 1566 | 9606 | binlog_hton->savepoint_rollback_can_release_mdl = | |
| 1567 | binlog_savepoint_rollback_can_release_mdl; | ||
| 1568 | 9606 | binlog_hton->commit = binlog_commit; | |
| 1569 | 9606 | binlog_hton->rollback = binlog_rollback; | |
| 1570 | 9606 | binlog_hton->prepare = binlog_prepare; | |
| 1571 | 9606 | binlog_hton->start_consistent_snapshot = binlog_start_consistent_snapshot; | |
| 1572 | 9606 | binlog_hton->clone_consistent_snapshot = binlog_clone_consistent_snapshot; | |
| 1573 | 9606 | binlog_hton->set_prepared_in_tc = binlog_set_prepared_in_tc; | |
| 1574 | 9606 | binlog_hton->recover = binlog_dummy_recover; | |
| 1575 | 9606 | binlog_hton->flags = HTON_NOT_USER_SELECTABLE | HTON_HIDDEN; | |
| 1576 | 9606 | return 0; | |
| 1577 | } | ||
| 1578 | |||
| 1579 | 8252 | static int binlog_deinit(void *) { | |
| 1580 | /* Using binlog as TC after the binlog has been unloaded, won't work */ | ||
| 1581 |
2/2✓ Branch 0 taken 7864 times.
✓ Branch 1 taken 388 times.
|
8252 | if (tc_log == &mysql_bin_log) tc_log = nullptr; |
| 1582 | 8252 | binlog_hton = nullptr; | |
| 1583 | 8252 | return 0; | |
| 1584 | } | ||
| 1585 | |||
| 1586 | 40792 | static int binlog_close_connection(handlerton *, THD *thd) { | |
| 1587 |
1/2✓ Branch 0 taken 40796 times.
✗ Branch 1 not taken.
|
40792 | DBUG_TRACE; |
| 1588 |
1/2✓ Branch 0 taken 40796 times.
✗ Branch 1 not taken.
|
40796 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); |
| 1589 | |||
| 1590 | #ifdef WITH_WSREP | ||
| 1591 |
2/4✓ Branch 0 taken 40797 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 40797 times.
|
40796 | if (!cache_mngr->is_binlog_empty()) { |
| 1592 | /* binlog should be empty during close connection. pending binlog represent | ||
| 1593 | node was shutdown with replication leftover. */ | ||
| 1594 | uchar *buf; | ||
| 1595 | ✗ | size_t len = 0; | |
| 1596 | |||
| 1597 | ✗ | IO_CACHE_binlog_cache_storage *trx_cache = wsrep_get_trans_cache(thd, true); | |
| 1598 | ✗ | wsrep_write_cache_buf(trx_cache, &buf, &len); | |
| 1599 | ✗ | WSREP_WARN( | |
| 1600 | "binlog trx cache not empty (%llu bytes) @ connection close %llu", | ||
| 1601 | (unsigned long long)len, (unsigned long long)thd->thread_id()); | ||
| 1602 | ✗ | if (len > 0) wsrep_dump_rbr_buf(thd, buf, len); | |
| 1603 | |||
| 1604 | IO_CACHE_binlog_cache_storage *stmt_cache = | ||
| 1605 | ✗ | wsrep_get_trans_cache(thd, false); | |
| 1606 | ✗ | wsrep_write_cache_buf(stmt_cache, &buf, &len); | |
| 1607 | ✗ | WSREP_WARN( | |
| 1608 | "binlog stmt cache not empty (%llu bytes) @ connection close %llu", | ||
| 1609 | (unsigned long long)len, (unsigned long long)thd->thread_id()); | ||
| 1610 | ✗ | if (len > 0) wsrep_dump_rbr_buf(thd, buf, len); | |
| 1611 | } | ||
| 1612 | #endif /* WITH_WSREP */ | ||
| 1613 | |||
| 1614 |
2/4✓ Branch 0 taken 40774 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 40774 times.
|
40797 | assert(cache_mngr->is_binlog_empty()); |
| 1615 |
5/8✓ Branch 0 taken 40795 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 40793 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 40791 times.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
|
40774 | DBUG_PRINT("debug", ("Set ha_data slot %d to 0x%llx", binlog_hton->slot, |
| 1616 | (ulonglong) nullptr)); | ||
| 1617 |
1/2✓ Branch 0 taken 40797 times.
✗ Branch 1 not taken.
|
40793 | thd_set_ha_data(thd, binlog_hton, nullptr); |
| 1618 | 40797 | cache_mngr->~binlog_cache_mngr(); | |
| 1619 |
1/2✓ Branch 0 taken 40796 times.
✗ Branch 1 not taken.
|
40793 | my_free(cache_mngr); |
| 1620 | 40791 | return 0; | |
| 1621 | 40796 | } | |
| 1622 | |||
| 1623 | 14511095 | int binlog_cache_data::write_event(Log_event *ev) { | |
| 1624 |
1/2✓ Branch 0 taken 14512417 times.
✗ Branch 1 not taken.
|
14511095 | DBUG_TRACE; |
| 1625 | |||
| 1626 |
2/2✓ Branch 0 taken 14103199 times.
✓ Branch 1 taken 409218 times.
|
14512417 | if (ev != nullptr) { |
| 1627 |
2/6✓ Branch 0 taken 14102830 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14102830 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
14103199 | DBUG_EXECUTE_IF("simulate_disk_full_at_flush_pending", |
| 1628 | { DBUG_SET("+d,simulate_file_write_error"); }); | ||
| 1629 | |||
| 1630 |
3/4✓ Branch 0 taken 14103410 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78 times.
✓ Branch 3 taken 14103332 times.
|
14102830 | if (binary_event_serialize(ev, &m_cache)) { |
| 1631 |
2/10✓ Branch 0 taken 78 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
78 | DBUG_EXECUTE_IF("simulate_disk_full_at_flush_pending", { |
| 1632 | DBUG_SET("-d,simulate_file_write_error"); | ||
| 1633 | DBUG_SET("-d,simulate_disk_full_at_flush_pending"); | ||
| 1634 | /* | ||
| 1635 | after +d,simulate_file_write_error the local cache | ||
| 1636 | is in unsane state. Since -d,simulate_file_write_error | ||
| 1637 | revokes the first simulation do_write_cache() | ||
| 1638 | can't be run without facing an assert. | ||
| 1639 | So it's blocked with the following 2nd simulation: | ||
| 1640 | */ | ||
| 1641 | DBUG_SET("+d,simulate_do_write_cache_failure"); | ||
| 1642 | }); | ||
| 1643 | 78 | return 1; | |
| 1644 | } | ||
| 1645 |
6/6✓ Branch 0 taken 12381032 times.
✓ Branch 1 taken 1722028 times.
✓ Branch 2 taken 627 times.
✓ Branch 3 taken 12380475 times.
✓ Branch 4 taken 1722655 times.
✓ Branch 5 taken 12380475 times.
|
26484434 | if (ev->get_type_code() == binary_log::XID_EVENT || |
| 1646 | 12381032 | ev->get_type_code() == binary_log::XA_PREPARE_LOG_EVENT) | |
| 1647 | 1722655 | flags.with_xid = true; | |
| 1648 |
2/2✓ Branch 0 taken 91511 times.
✓ Branch 1 taken 14011672 times.
|
14103130 | if (ev->is_using_immediate_logging()) flags.immediate = true; |
| 1649 | /* DDL gets marked as xid-requiring at its caching. */ | ||
| 1650 |
2/2✓ Branch 0 taken 317991 times.
✓ Branch 1 taken 13785262 times.
|
14103183 | if (is_atomic_ddl_event(ev)) flags.with_xid = true; |
| 1651 | /* With respect to the event type being written */ | ||
| 1652 |
3/4✓ Branch 0 taken 14103244 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 832137 times.
✓ Branch 3 taken 13271107 times.
|
14103253 | if (ev->is_sbr_logging_format()) flags.with_sbr = true; |
| 1653 |
3/4✓ Branch 0 taken 14102744 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8887389 times.
✓ Branch 3 taken 5215355 times.
|
14103244 | if (ev->is_rbr_logging_format()) flags.with_rbr = true; |
| 1654 | /* With respect to empty transactions */ | ||
| 1655 |
3/4✓ Branch 0 taken 14102768 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2187011 times.
✓ Branch 3 taken 11915757 times.
|
14102744 | if (ev->starts_group()) flags.with_start = true; |
| 1656 |
3/4✓ Branch 0 taken 14103160 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2182181 times.
✓ Branch 3 taken 11920979 times.
|
14102768 | if (ev->ends_group()) flags.with_end = true; |
| 1657 |
8/10✓ Branch 0 taken 14103279 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11916063 times.
✓ Branch 3 taken 2187216 times.
✓ Branch 4 taken 11916066 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9733920 times.
✓ Branch 7 taken 2182146 times.
✓ Branch 8 taken 9733929 times.
✓ Branch 9 taken 4369353 times.
|
14103160 | if (!ev->starts_group() && !ev->ends_group()) flags.with_content = true; |
| 1658 | 14103282 | event_counter++; | |
| 1659 |
5/8✓ Branch 0 taken 14102771 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14102817 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 176 times.
✓ Branch 5 taken 14102641 times.
✓ Branch 6 taken 198 times.
✗ Branch 7 not taken.
|
14103282 | DBUG_PRINT("debug", |
| 1660 | ("event_counter= %lu", static_cast<ulong>(event_counter))); | ||
| 1661 | } | ||
| 1662 | 14512057 | return 0; | |
| 1663 | 14512135 | } | |
| 1664 | |||
| 1665 | 2494619 | bool MYSQL_BIN_LOG::assign_automatic_gtids_to_flush_group(THD *first_seen) { | |
| 1666 |
1/2✓ Branch 0 taken 2494619 times.
✗ Branch 1 not taken.
|
2494619 | DBUG_TRACE; |
| 1667 | 2494619 | bool error = false; | |
| 1668 | 2494619 | bool is_global_sid_locked = false; | |
| 1669 | 2494619 | rpl_sidno locked_sidno = 0; | |
| 1670 | |||
| 1671 |
2/2✓ Branch 0 taken 2585324 times.
✓ Branch 1 taken 2494619 times.
|
5079943 | for (THD *head = first_seen; head; head = head->next_to_commit) { |
| 1672 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2585324 times.
|
2585324 | assert(head->variables.gtid_next.type != UNDEFINED_GTID); |
| 1673 | |||
| 1674 | /* Generate GTID */ | ||
| 1675 |
2/2✓ Branch 0 taken 2273152 times.
✓ Branch 1 taken 312172 times.
|
2585324 | if (head->variables.gtid_next.type == AUTOMATIC_GTID) { |
| 1676 |
2/2✓ Branch 0 taken 2202278 times.
✓ Branch 1 taken 70874 times.
|
2273152 | if (!is_global_sid_locked) { |
| 1677 |
1/2✓ Branch 0 taken 2202278 times.
✗ Branch 1 not taken.
|
2202278 | global_sid_lock->rdlock(); |
| 1678 | 2202278 | is_global_sid_locked = true; | |
| 1679 | } | ||
| 1680 |
3/6✓ Branch 0 taken 2273152 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2273152 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2273152 times.
✗ Branch 5 not taken.
|
2273152 | if (gtid_state->generate_automatic_gtid( |
| 1681 | head, | ||
| 1682 | head->get_transaction()->get_rpl_transaction_ctx()->get_sidno(), | ||
| 1683 | head->get_transaction()->get_rpl_transaction_ctx()->get_gno(), | ||
| 1684 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2273151 times.
|
2273152 | &locked_sidno) != RETURN_STATUS_OK) { |
| 1685 | 1 | head->commit_error = THD::CE_FLUSH_GNO_EXHAUSTED_ERROR; | |
| 1686 | 1 | error = true; | |
| 1687 | } | ||
| 1688 | } else { | ||
| 1689 |
3/8✓ Branch 0 taken 312172 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 312172 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 312172 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
312172 | DBUG_PRINT("info", |
| 1690 | ("thd->variables.gtid_next.type=%d " | ||
| 1691 | "thd->owned_gtid.sidno=%d", | ||
| 1692 | head->variables.gtid_next.type, head->owned_gtid.sidno)); | ||
| 1693 |
2/2✓ Branch 0 taken 87194 times.
✓ Branch 1 taken 224978 times.
|
312172 | if (head->variables.gtid_next.type == ASSIGNED_GTID) |
| 1694 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 87194 times.
|
87194 | assert(head->owned_gtid.sidno > 0); |
| 1695 | else { | ||
| 1696 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 224978 times.
|
224978 | assert(head->variables.gtid_next.type == ANONYMOUS_GTID); |
| 1697 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 224978 times.
|
224978 | assert(head->owned_gtid.sidno == THD::OWNED_SIDNO_ANONYMOUS); |
| 1698 | } | ||
| 1699 | } | ||
| 1700 | } | ||
| 1701 | |||
| 1702 |
3/4✓ Branch 0 taken 36717 times.
✓ Branch 1 taken 2457902 times.
✓ Branch 2 taken 36717 times.
✗ Branch 3 not taken.
|
2494619 | if (locked_sidno > 0) gtid_state->unlock_sidno(locked_sidno); |
| 1703 | |||
| 1704 |
3/4✓ Branch 0 taken 2202278 times.
✓ Branch 1 taken 292341 times.
✓ Branch 2 taken 2202278 times.
✗ Branch 3 not taken.
|
2494619 | if (is_global_sid_locked) global_sid_lock->unlock(); |
| 1705 | |||
| 1706 | 2494619 | return error; | |
| 1707 | 2494619 | } | |
| 1708 | |||
| 1709 | /** | ||
| 1710 | Write the Gtid_log_event to the binary log (prior to writing the | ||
| 1711 | statement or transaction cache). | ||
| 1712 | |||
| 1713 | @param thd Thread that is committing. | ||
| 1714 | @param cache_data The cache that is flushing. | ||
| 1715 | @param writer The event will be written to this Binlog_event_writer object. | ||
| 1716 | |||
| 1717 | @retval false Success. | ||
| 1718 | @retval true Error. | ||
| 1719 | */ | ||
| 1720 | 2590142 | bool MYSQL_BIN_LOG::write_transaction(THD *thd, binlog_cache_data *cache_data, | |
| 1721 | Binlog_event_writer *writer) { | ||
| 1722 |
1/2✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
|
2590142 | DBUG_TRACE; |
| 1723 | |||
| 1724 | /* | ||
| 1725 | The GTID for the THD was assigned at | ||
| 1726 | assign_automatic_gtids_to_flush_group() | ||
| 1727 | */ | ||
| 1728 |
3/4✓ Branch 0 taken 123932 times.
✓ Branch 1 taken 2466210 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 123932 times.
|
2590142 | assert(thd->owned_gtid.sidno == THD::OWNED_SIDNO_ANONYMOUS || |
| 1729 | thd->owned_gtid.sidno > 0); | ||
| 1730 | |||
| 1731 | int64 sequence_number, last_committed; | ||
| 1732 | /* Generate logical timestamps for MTS */ | ||
| 1733 |
1/2✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
|
2590142 | m_dependency_tracker.get_dependency(thd, sequence_number, last_committed); |
| 1734 | |||
| 1735 | /* | ||
| 1736 | In case both the transaction cache and the statement cache are | ||
| 1737 | non-empty, both will be flushed in sequence and logged as | ||
| 1738 | different transactions. Then the second transaction must only | ||
| 1739 | be executed after the first one has committed. Therefore, we | ||
| 1740 | need to set last_committed for the second transaction equal to | ||
| 1741 | last_committed for the first transaction. This is done in | ||
| 1742 | binlog_cache_data::flush. binlog_cache_data::flush uses the | ||
| 1743 | condition trn_ctx->last_committed==SEQ_UNINIT to detect this | ||
| 1744 | situation, hence the need to set it here. | ||
| 1745 | */ | ||
| 1746 | 2590142 | thd->get_transaction()->last_committed = SEQ_UNINIT; | |
| 1747 | |||
| 1748 | /* | ||
| 1749 | For delayed replication and also for the purpose of lag monitoring, | ||
| 1750 | we assume that the commit timestamp of the transaction is the time of | ||
| 1751 | executing this code (the time of writing the Gtid_log_event to the binary | ||
| 1752 | log). | ||
| 1753 | */ | ||
| 1754 | 2590142 | ulonglong immediate_commit_timestamp = my_micro_time(); | |
| 1755 | |||
| 1756 | /* | ||
| 1757 | When the original_commit_timestamp session variable is set to a value | ||
| 1758 | other than UNDEFINED_COMMIT_TIMESTAMP, it means that either the timestamp | ||
| 1759 | is known ( > 0 ) or the timestamp is not known ( == 0 ). | ||
| 1760 | */ | ||
| 1761 | 2590142 | ulonglong original_commit_timestamp = | |
| 1762 | thd->variables.original_commit_timestamp; | ||
| 1763 | /* | ||
| 1764 | When original_commit_timestamp == UNDEFINED_COMMIT_TIMESTAMP, we assume | ||
| 1765 | that: | ||
| 1766 | a) it is not known if this thread is a slave applier ( = 0 ); | ||
| 1767 | b) this is a new transaction ( = immediate_commit_timestamp); | ||
| 1768 | */ | ||
| 1769 |
2/2✓ Branch 0 taken 2297593 times.
✓ Branch 1 taken 292549 times.
|
2590142 | if (original_commit_timestamp == UNDEFINED_COMMIT_TIMESTAMP) { |
| 1770 | /* | ||
| 1771 | When applying a transaction using replication, assume that the | ||
| 1772 | original commit timestamp is not known (the transaction wasn't | ||
| 1773 | originated on the current server). | ||
| 1774 | */ | ||
| 1775 |
6/6✓ Branch 0 taken 2297467 times.
✓ Branch 1 taken 126 times.
✓ Branch 2 taken 46 times.
✓ Branch 3 taken 2297421 times.
✓ Branch 4 taken 172 times.
✓ Branch 5 taken 2297421 times.
|
2297593 | if (thd->slave_thread || thd->is_binlog_applier()) { |
| 1776 | 172 | original_commit_timestamp = 0; | |
| 1777 | } else | ||
| 1778 | /* Assume that this transaction is original from this server */ | ||
| 1779 | { | ||
| 1780 |
2/4✓ Branch 0 taken 2297421 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2297421 times.
|
2297421 | DBUG_EXECUTE_IF("rpl_invalid_gtid_timestamp", |
| 1781 | // add one our to the commit timestamps | ||
| 1782 | immediate_commit_timestamp += 3600000000;); | ||
| 1783 | 2297421 | original_commit_timestamp = immediate_commit_timestamp; | |
| 1784 | } | ||
| 1785 | } else { | ||
| 1786 | // Clear the session variable to have cleared states for next transaction. | ||
| 1787 | 292549 | thd->variables.original_commit_timestamp = UNDEFINED_COMMIT_TIMESTAMP; | |
| 1788 | } | ||
| 1789 | |||
| 1790 | uint32_t trx_immediate_server_version = | ||
| 1791 | 2590142 | do_server_version_int(::server_version); | |
| 1792 | // Clear the session variable to have cleared states for next transaction. | ||
| 1793 | 2590142 | thd->variables.immediate_server_version = UNDEFINED_SERVER_VERSION; | |
| 1794 |
3/4✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2590138 times.
|
2590142 | DBUG_EXECUTE_IF("fixed_server_version", |
| 1795 | trx_immediate_server_version = 888888;); | ||
| 1796 |
3/4✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2590138 times.
|
2590142 | DBUG_EXECUTE_IF("gr_fixed_server_version", |
| 1797 | trx_immediate_server_version = 777777;); | ||
| 1798 | |||
| 1799 | /* | ||
| 1800 | When the original_server_version session variable is set to a value | ||
| 1801 | other than UNDEFINED_SERVER_VERSION, it means that either the | ||
| 1802 | server version is known or the server_version is not known | ||
| 1803 | (UNKNOWN_SERVER_VERSION). | ||
| 1804 | */ | ||
| 1805 | 2590142 | uint32_t trx_original_server_version = thd->variables.original_server_version; | |
| 1806 | |||
| 1807 | /* | ||
| 1808 | When original_server_version == UNDEFINED_SERVER_VERSION, we assume | ||
| 1809 | that: | ||
| 1810 | a) it is not known if this thread is a slave applier ( = 0 ); | ||
| 1811 | b) this is a new transaction ( = ::server_version); | ||
| 1812 | */ | ||
| 1813 |
2/2✓ Branch 0 taken 2297613 times.
✓ Branch 1 taken 292529 times.
|
2590142 | if (trx_original_server_version == UNDEFINED_SERVER_VERSION) { |
| 1814 | /* | ||
| 1815 | When applying a transaction using replication, assume that the | ||
| 1816 | original server version is not known (the transaction wasn't | ||
| 1817 | originated on the current server). | ||
| 1818 | */ | ||
| 1819 |
6/6✓ Branch 0 taken 2297461 times.
✓ Branch 1 taken 152 times.
✓ Branch 2 taken 40 times.
✓ Branch 3 taken 2297421 times.
✓ Branch 4 taken 192 times.
✓ Branch 5 taken 2297421 times.
|
2297613 | if (thd->slave_thread || thd->is_binlog_applier()) { |
| 1820 | 192 | trx_original_server_version = UNKNOWN_SERVER_VERSION; | |
| 1821 | } else | ||
| 1822 | /* Assume that this transaction is original from this server */ | ||
| 1823 | { | ||
| 1824 | 2297421 | trx_original_server_version = trx_immediate_server_version; | |
| 1825 | } | ||
| 1826 | } else { | ||
| 1827 | // Clear the session variable to have cleared states for next transaction. | ||
| 1828 | 292529 | thd->variables.original_server_version = UNDEFINED_SERVER_VERSION; | |
| 1829 | } | ||
| 1830 | Gtid_log_event gtid_event( | ||
| 1831 | 2590142 | thd, cache_data->is_trx_cache(), last_committed, sequence_number, | |
| 1832 | 2590142 | cache_data->may_have_sbr_stmts(), original_commit_timestamp, | |
| 1833 | immediate_commit_timestamp, trx_original_server_version, | ||
| 1834 |
1/2✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
|
2590142 | trx_immediate_server_version); |
| 1835 | |||
| 1836 | // Set the transaction length, based on cache info | ||
| 1837 |
2/4✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590142 times.
✗ Branch 3 not taken.
|
2590142 | gtid_event.set_trx_length_by_cache_size(cache_data->get_byte_position(), |
| 1838 | 2590142 | writer->is_checksum_enabled(), | |
| 1839 | 2590142 | cache_data->get_event_counter()); | |
| 1840 | |||
| 1841 |
6/10✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590142 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 2590031 times.
✓ Branch 6 taken 111 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 111 times.
✗ Branch 9 not taken.
|
2590142 | DBUG_PRINT("debug", ("cache_data->get_byte_position()= %llu", |
| 1842 | cache_data->get_byte_position())); | ||
| 1843 |
5/8✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590142 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 2590031 times.
✓ Branch 6 taken 111 times.
✗ Branch 7 not taken.
|
2590142 | DBUG_PRINT("debug", ("cache_data->get_event_counter()= %lu", |
| 1844 | static_cast<ulong>(cache_data->get_event_counter()))); | ||
| 1845 |
6/10✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590142 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 2590031 times.
✓ Branch 6 taken 111 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 111 times.
✗ Branch 9 not taken.
|
2590142 | DBUG_PRINT("debug", ("writer->is_checksum_enabled()= %s", |
| 1846 | YESNO(writer->is_checksum_enabled()))); | ||
| 1847 |
6/10✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590142 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 2590031 times.
✓ Branch 6 taken 111 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 111 times.
✗ Branch 9 not taken.
|
2590142 | DBUG_PRINT("debug", ("gtid_event.get_event_length()= %lu", |
| 1848 | static_cast<ulong>(gtid_event.get_event_length()))); | ||
| 1849 |
5/8✓ Branch 0 taken 2590142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590142 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 114 times.
✓ Branch 5 taken 2590028 times.
✓ Branch 6 taken 114 times.
✗ Branch 7 not taken.
|
2590142 | DBUG_PRINT("info", |
| 1850 | ("transaction_length= %llu", gtid_event.transaction_length)); | ||
| 1851 | |||
| 1852 | #ifdef WITH_WSREP | ||
| 1853 | 2590142 | bool ret = 0; | |
| 1854 | |||
| 1855 |
2/2✓ Branch 0 taken 2590135 times.
✓ Branch 1 taken 7 times.
|
2590142 | if (!(thd->variables.option_bits & OPTION_BIN_LOG_INTERNAL_OFF) && |
| 1856 |
2/2✓ Branch 0 taken 125 times.
✓ Branch 1 taken 2590010 times.
|
2590135 | !(thd->variables.option_bits & OPTION_BIN_LOG)) |
| 1857 | 125 | goto end; | |
| 1858 | |||
| 1859 |
1/2✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
|
2590017 | ret = gtid_event.write(writer); |
| 1860 | #else | ||
| 1861 | bool ret = gtid_event.write(writer); | ||
| 1862 | #endif | ||
| 1863 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2590017 times.
|
2590017 | if (ret) goto end; |
| 1864 | |||
| 1865 | /* | ||
| 1866 | finally write the transaction data, if it was not compressed | ||
| 1867 | and written as part of the gtid event already | ||
| 1868 | */ | ||
| 1869 |
1/2✓ Branch 0 taken 2590014 times.
✗ Branch 1 not taken.
|
2590017 | ret = mysql_bin_log.write_cache(thd, cache_data, writer); |
| 1870 | |||
| 1871 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2590011 times.
|
2590014 | if (!ret) { |
| 1872 | // update stats if monitoring is active | ||
| 1873 |
1/2✓ Branch 0 taken 2590011 times.
✗ Branch 1 not taken.
|
2590011 | binlog::global_context.monitoring_context() |
| 1874 |
1/2✓ Branch 0 taken 2590011 times.
✗ Branch 1 not taken.
|
2590011 | .transaction_compression() |
| 1875 |
1/2✓ Branch 0 taken 2590011 times.
✗ Branch 1 not taken.
|
5180022 | .update(binlog::monitoring::log_type::BINARY, |
| 1876 | 2590011 | cache_data->get_compression_type(), thd->owned_gtid, | |
| 1877 | 2590011 | gtid_event.immediate_commit_timestamp, | |
| 1878 | cache_data->get_compressed_size(), | ||
| 1879 | cache_data->get_decompressed_size()); | ||
| 1880 | } | ||
| 1881 | |||
| 1882 | 3 | end: | |
| 1883 | 2590139 | return ret; | |
| 1884 | 2590139 | } | |
| 1885 | |||
| 1886 | 1675328 | int MYSQL_BIN_LOG::gtid_end_transaction(THD *thd) { | |
| 1887 |
1/2✓ Branch 0 taken 1676270 times.
✗ Branch 1 not taken.
|
1675328 | DBUG_TRACE; |
| 1888 | |||
| 1889 |
5/10✓ Branch 0 taken 1676211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1676264 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 91 times.
✓ Branch 5 taken 1676173 times.
✓ Branch 6 taken 91 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
1676270 | DBUG_PRINT("info", ("query=%s", thd->query().str)); |
| 1890 | |||
| 1891 |
2/2✓ Branch 0 taken 50506 times.
✓ Branch 1 taken 1624935 times.
|
1675441 | if (thd->owned_gtid.sidno > 0) { |
| 1892 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 50506 times.
|
50506 | assert(thd->variables.gtid_next.type == ASSIGNED_GTID); |
| 1893 | |||
| 1894 |
5/6✓ Branch 0 taken 50484 times.
✓ Branch 1 taken 22 times.
✓ Branch 2 taken 20156 times.
✓ Branch 3 taken 30328 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 20156 times.
|
50506 | if (!opt_bin_log || (thd->slave_thread && !opt_log_replica_updates)) { |
| 1895 | /* | ||
| 1896 | If the binary log is disabled for this thread (either by | ||
| 1897 | log_bin=0 or sql_log_bin=0 or by log_replica_updates=0 for a | ||
| 1898 | slave thread), then the statement must not be written to the | ||
| 1899 | binary log. In this case, we just save the GTID into the | ||
| 1900 | table directly. | ||
| 1901 | |||
| 1902 | (This only happens for DDL, since DML will save the GTID into | ||
| 1903 | table and release ownership inside ha_commit_trans.) | ||
| 1904 | */ | ||
| 1905 |
2/4✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
|
22 | if (gtid_state->save(thd) != 0) { |
| 1906 | ✗ | gtid_state->update_on_rollback(thd); | |
| 1907 | ✗ | return 1; | |
| 1908 |
3/4✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 17 times.
|
22 | } else if (!has_commit_order_manager(thd)) { |
| 1909 | /* | ||
| 1910 | The gtid_state->save implicitly performs the commit, in the following | ||
| 1911 | stack: | ||
| 1912 | Gtid_state::save -> | ||
| 1913 | Gtid_table_persistor::save -> | ||
| 1914 | Gtid_table_access_context::deinit -> | ||
| 1915 | System_table_access::close_table -> | ||
| 1916 | ha_commit_trans -> | ||
| 1917 | Relay_log_info::pre_commit -> | ||
| 1918 | Slave_worker::commit_positions(THD*) -> | ||
| 1919 | Slave_worker::commit_positions(THD*,Log_event*,...) -> | ||
| 1920 | Slave_worker::flush_info -> | ||
| 1921 | Rpl_info_handler::flush_info -> | ||
| 1922 | Rpl_info_table::do_flush_info -> | ||
| 1923 | Rpl_info_table_access::close_table -> | ||
| 1924 | System_table_access::close_table -> | ||
| 1925 | ha_commit_trans -> | ||
| 1926 | MYSQL_BIN_LOG::commit -> | ||
| 1927 | ha_commit_low | ||
| 1928 | |||
| 1929 | If replica-preserve-commit-order is disabled, it does not call | ||
| 1930 | update_on_commit from this stack. The reason is as follows: | ||
| 1931 | |||
| 1932 | In the normal case of MYSQL_BIN_LOG::commit, where the transaction is | ||
| 1933 | going to be written to the binary log, it invokes | ||
| 1934 | MYSQL_BIN_LOG::ordered_commit, which updates the GTID state (the call | ||
| 1935 | gtid_state->update_commit_group(first) in process_commit_stage_queue). | ||
| 1936 | However, when MYSQL_BIN_LOG::commit is invoked from this stack, it is | ||
| 1937 | because the transaction is not going to be written to the binary log, | ||
| 1938 | and then MYSQL_BIN_LOG::commit has a special case that calls | ||
| 1939 | ha_commit_low directly, skipping ordered_commit. Therefore, the GTID | ||
| 1940 | state is not updated in this stack. | ||
| 1941 | |||
| 1942 | On the other hand, if replica-preserve-commit-order is enabled, the | ||
| 1943 | logic that orders commit carries out a subset of the binlog group | ||
| 1944 | commit from within ha_commit_low, and this includes updating the GTID | ||
| 1945 | state. In particular, there is the following call stack under | ||
| 1946 | ha_commit_low: | ||
| 1947 | |||
| 1948 | ha_commit_low -> | ||
| 1949 | Commit_order_manager::wait_and_finish -> | ||
| 1950 | Commit_order_manager::finish -> | ||
| 1951 | Commit_order_manager::flush_engine_and_signal_threads -> | ||
| 1952 | Gtid_state::update_commit_group | ||
| 1953 | |||
| 1954 | Therefore, it is necessary to call update_on_commit only in case we | ||
| 1955 | are not using replica-preserve-commit-order here. | ||
| 1956 | */ | ||
| 1957 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | gtid_state->update_on_commit(thd); |
| 1958 | } | ||
| 1959 | } else { | ||
| 1960 | /* | ||
| 1961 | If statement is supposed to be written to binlog, we write it | ||
| 1962 | to the binary log. Inserting into table and releasing | ||
| 1963 | ownership will be done in the binlog commit handler. | ||
| 1964 | */ | ||
| 1965 | |||
| 1966 | /* | ||
| 1967 | thd->cache_mngr may be uninitialized if the first transaction | ||
| 1968 | executed by the client is empty. | ||
| 1969 | */ | ||
| 1970 |
2/4✓ Branch 0 taken 50484 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 50484 times.
|
50486 | if (thd->binlog_setup_trx_data()) return 1; |
| 1971 |
1/2✓ Branch 0 taken 50484 times.
✗ Branch 1 not taken.
|
50484 | binlog_cache_data *cache_data = &thd_get_cache_mngr(thd)->trx_cache; |
| 1972 | |||
| 1973 | // Generate BEGIN event | ||
| 1974 | Query_log_event qinfo(thd, STRING_WITH_LEN("BEGIN"), true, false, true, 0, | ||
| 1975 |
1/2✓ Branch 0 taken 50484 times.
✗ Branch 1 not taken.
|
50484 | true); |
| 1976 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 50484 times.
|
50484 | assert(!qinfo.is_using_immediate_logging()); |
| 1977 | |||
| 1978 | #ifdef WITH_WSREP | ||
| 1979 |
6/8✓ Branch 0 taken 22 times.
✓ Branch 1 taken 50462 times.
✓ Branch 2 taken 22 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✓ Branch 5 taken 11 times.
✓ Branch 6 taken 11 times.
✗ Branch 7 not taken.
|
50484 | if (WSREP_ON && thd->slave_thread && !thd->wsrep_applier) { |
| 1980 | /* If the galera node is acting as async slave then capture | ||
| 1981 | GTID event from the async slave applied thread and mark it for | ||
| 1982 | replication in galera channel. */ | ||
| 1983 | 11 | thd->wsrep_replicate_GTID = true; | |
| 1984 | |||
| 1985 | /* Replicating DDL (from async-master) with replication filter will | ||
| 1986 | cause DDL to get skipped way-early before the MySQL flow starts | ||
| 1987 | transaction. Even though there is nothing to commit Galera/PXC flow | ||
| 1988 | needs to capture empty event with GTID and replicate it. For this | ||
| 1989 | it needs an active transaction. Start a transaction in Galera/PXC | ||
| 1990 | context that will be committed as part of binlog_commit action | ||
| 1991 | called below. */ | ||
| 1992 |
3/4✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 8 times.
|
11 | if (!wsrep_is_active(thd)) { |
| 1993 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | wsrep_start_transaction(thd, thd->wsrep_next_trx_id()); |
| 1994 | } | ||
| 1995 | } | ||
| 1996 | #endif /* WITH_WSREP */ | ||
| 1997 | /* | ||
| 1998 | Write BEGIN event and then commit (which will generate commit | ||
| 1999 | event and Gtid_log_event) | ||
| 2000 | */ | ||
| 2001 |
3/8✓ Branch 0 taken 50484 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50484 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 50484 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
50484 | DBUG_PRINT("debug", ("Writing to trx_cache")); |
| 2002 |
7/10✓ Branch 0 taken 50484 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 50484 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 50484 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 50482 times.
✓ Branch 8 taken 2 times.
✓ Branch 9 taken 50482 times.
|
50484 | if (cache_data->write_event(&qinfo) || mysql_bin_log.commit(thd, true)) |
| 2003 | 2 | return 1; | |
| 2004 | |||
| 2005 | #ifdef WITH_WSREP | ||
| 2006 | 50482 | thd->wsrep_replicate_GTID = false; | |
| 2007 | #endif /* WITH_WSREP */ | ||
| 2008 |
2/2✓ Branch 0 taken 50482 times.
✓ Branch 1 taken 2 times.
|
50484 | } |
| 2009 |
2/2✓ Branch 0 taken 1558282 times.
✓ Branch 1 taken 66653 times.
|
1624935 | } else if (thd->owned_gtid.sidno == THD::OWNED_SIDNO_ANONYMOUS || |
| 2010 | /* | ||
| 2011 | A transaction with an empty owned gtid should call | ||
| 2012 | end_gtid_violating_transaction(...) to clear the | ||
| 2013 | flag thd->has_gtid_consistency_violatoin in case | ||
| 2014 | it is set. It missed the clear in ordered_commit, | ||
| 2015 | because its binlog transaction cache is empty. | ||
| 2016 | */ | ||
| 2017 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1558432 times.
|
1558282 | thd->has_gtid_consistency_violation) |
| 2018 | |||
| 2019 | { | ||
| 2020 |
1/2✓ Branch 0 taken 66626 times.
✗ Branch 1 not taken.
|
66503 | gtid_state->update_on_commit(thd); |
| 2021 | #ifdef WITH_WSREP | ||
| 2022 | /* if setup is operating with gtid_mode=OFF + replication filter | ||
| 2023 | then replication of DML event can cause start of transaction (as part of | ||
| 2024 | BEGIN event) but the followup action of apply is blocked or skipped | ||
| 2025 | by presence of replication filter. | ||
| 2026 | binlog-commit will commit the transaction in InnoDB world but | ||
| 2027 | PXC needs to be ensure the said transaction is closed as empty | ||
| 2028 | transaction (just like SELECT empty transaction). */ | ||
| 2029 |
3/4✓ Branch 0 taken 66625 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 66611 times.
|
66626 | if (wsrep_is_active(thd)) { |
| 2030 |
1/2✓ Branch 0 taken 19 times.
✗ Branch 1 not taken.
|
14 | wsrep_commit_empty(thd, true); |
| 2031 | } | ||
| 2032 | #endif /* WITH_WSREP */ | ||
| 2033 |
4/4✓ Branch 0 taken 12694 times.
✓ Branch 1 taken 1545738 times.
✓ Branch 2 taken 12696 times.
✓ Branch 3 taken 1545737 times.
|
1571127 | } else if (thd->variables.gtid_next.type == ASSIGNED_GTID && |
| 2034 |
2/4✓ Branch 0 taken 12695 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12696 times.
✗ Branch 3 not taken.
|
12694 | thd->owned_gtid_is_empty()) { |
| 2035 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12696 times.
|
12696 | assert(thd->has_gtid_consistency_violation == false); |
| 2036 |
1/2✓ Branch 0 taken 12693 times.
✗ Branch 1 not taken.
|
12696 | gtid_state->update_on_commit(thd); |
| 2037 | } | ||
| 2038 | |||
| 2039 | 1675564 | return 0; | |
| 2040 | 1675566 | } | |
| 2041 | |||
| 2042 | 77 | bool MYSQL_BIN_LOG::reencrypt_logs() { | |
| 2043 |
1/2✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
|
77 | DBUG_TRACE; |
| 2044 | |||
| 2045 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 77 times.
|
77 | if (!is_open()) return false; |
| 2046 | |||
| 2047 | 77 | std::string error_message; | |
| 2048 | /* Gather the set of files to be accessed. */ | ||
| 2049 | 77 | list<string> filename_list; | |
| 2050 | 77 | LOG_INFO linfo; | |
| 2051 | 77 | int error = 0; | |
| 2052 | 77 | list<string>::reverse_iterator rit; | |
| 2053 | |||
| 2054 | /* Read binary/relay log file names from index file. */ | ||
| 2055 |
1/2✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
|
77 | mysql_mutex_lock(&LOCK_index); |
| 2056 |
3/4✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
✓ Branch 3 taken 77 times.
|
1434 | for (error = find_log_pos(&linfo, nullptr, false); !error; |
| 2057 | 1357 | error = find_next_log(&linfo, false)) { | |
| 2058 |
3/6✓ Branch 0 taken 1357 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1357 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1357 times.
✗ Branch 5 not taken.
|
1357 | filename_list.push_back(string(linfo.log_file_name)); |
| 2059 | } | ||
| 2060 |
1/2✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
|
77 | mysql_mutex_unlock(&LOCK_index); |
| 2061 |
3/4✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 75 times.
|
154 | if (error != LOG_INFO_EOF || |
| 2062 |
3/4✓ Branch 0 taken 77 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 75 times.
|
77 | DBUG_EVALUATE_IF("fail_to_open_index_file", true, false)) { |
| 2063 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | error_message.assign("I/O error reading index file '"); |
| 2064 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | error_message.append(index_file_name); |
| 2065 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | error_message.append("'"); |
| 2066 | 2 | goto err; | |
| 2067 | } | ||
| 2068 | |||
| 2069 | 75 | rit = filename_list.rbegin(); | |
| 2070 | /* Skip the last binary/relay log. */ | ||
| 2071 |
3/6✓ Branch 0 taken 75 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 75 times.
✗ Branch 5 not taken.
|
75 | if (rit != filename_list.rend()) rit++; |
| 2072 | /* Iterate backwards through binary/relay logs. */ | ||
| 2073 |
3/4✓ Branch 0 taken 1226 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1162 times.
✓ Branch 3 taken 64 times.
|
1226 | while (rit != filename_list.rend()) { |
| 2074 |
1/2✓ Branch 0 taken 1162 times.
✗ Branch 1 not taken.
|
1162 | const char *filename = rit->c_str(); |
| 2075 |
4/6✓ Branch 0 taken 1162 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1161 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
1162 | DBUG_EXECUTE_IF("purge_logs_during_reencryption", { |
| 2076 | purge_logs(filename, true, true /*need_lock_index=true*/, | ||
| 2077 | true /*need_update_threads=true*/, nullptr, false); | ||
| 2078 | }); | ||
| 2079 | 1162 | MUTEX_LOCK(lock, &LOCK_index); | |
| 2080 | std::unique_ptr<Binlog_ofile> ofile( | ||
| 2081 |
1/2✓ Branch 0 taken 1162 times.
✗ Branch 1 not taken.
|
1162 | Binlog_ofile::open_existing(key_file_binlog, filename, MYF(MY_WME))); |
| 2082 | |||
| 2083 | 1162 | if (ofile == nullptr || | |
| 2084 |
7/8✓ Branch 0 taken 1161 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1161 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1159 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 4 times.
✓ Branch 7 taken 1158 times.
|
2321 | DBUG_EVALUATE_IF("fail_to_open_log_file", true, false) || |
| 2085 |
3/4✓ Branch 0 taken 1159 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1158 times.
|
1159 | DBUG_EVALUATE_IF("fail_to_read_index_file", true, false)) { |
| 2086 | /* If we can not open the log file, check if it exists in index file. */ | ||
| 2087 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | error = find_log_pos(&linfo, filename, false); |
| 2088 |
3/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 3 times.
|
4 | DBUG_EXECUTE_IF("fail_to_read_index_file", error = LOG_INFO_IO;); |
| 2089 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
|
4 | if (error == LOG_INFO_EOF) { |
| 2090 | /* If it does not exist in index file, re-encryption has finished. */ | ||
| 2091 |
5/10✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
|
1 | if (current_thd->is_error()) current_thd->clear_error(); |
| 2092 | 1 | break; | |
| 2093 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
|
3 | } else if (error == 0) { |
| 2094 | /* If it exists in index file, failed to open the log file. */ | ||
| 2095 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | error_message.assign("Failed to open log file '"); |
| 2096 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | error_message.append(filename); |
| 2097 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | error_message.append("'"); |
| 2098 | 2 | goto err; | |
| 2099 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | } else if (error == LOG_INFO_IO) { |
| 2100 | /* Failed to read index file. */ | ||
| 2101 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | error_message.assign("I/O error reading index file '"); |
| 2102 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | error_message.append(index_file_name); |
| 2103 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | error_message.append("'"); |
| 2104 | 1 | goto err; | |
| 2105 | } | ||
| 2106 | } | ||
| 2107 | |||
| 2108 |
2/2✓ Branch 0 taken 1070 times.
✓ Branch 1 taken 88 times.
|
1158 | if (ofile->is_encrypted()) { |
| 2109 | std::unique_ptr<Truncatable_ostream> pipeline_head = | ||
| 2110 | 1070 | ofile->get_pipeline_head(); | |
| 2111 | std::unique_ptr<Binlog_encryption_ostream> binlog_encryption_ostream( | ||
| 2112 | 1070 | down_cast<Binlog_encryption_ostream *>(pipeline_head.release())); | |
| 2113 | |||
| 2114 |
1/2✓ Branch 0 taken 1070 times.
✗ Branch 1 not taken.
|
1070 | auto ret_value = binlog_encryption_ostream->reencrypt(); |
| 2115 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1063 times.
|
1070 | if (ret_value.first) { |
| 2116 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | error_message.assign("Failed to re-encrypt log file '"); |
| 2117 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | error_message.append(filename); |
| 2118 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | error_message.append("': "); |
| 2119 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | error_message.append(ret_value.second.c_str()); |
| 2120 | 7 | goto err; | |
| 2121 | } | ||
| 2122 |
6/6✓ Branch 0 taken 1063 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 1063 times.
✓ Branch 3 taken 7 times.
✓ Branch 4 taken 1063 times.
✓ Branch 5 taken 7 times.
|
1084 | } |
| 2123 | |||
| 2124 |
1/2✓ Branch 0 taken 1151 times.
✗ Branch 1 not taken.
|
1151 | rit++; |
| 2125 |
6/6✓ Branch 0 taken 1151 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 1151 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 10 times.
|
1173 | } |
| 2126 | |||
| 2127 | 65 | filename_list.clear(); | |
| 2128 | |||
| 2129 | 65 | return false; | |
| 2130 | |||
| 2131 | 12 | err: | |
| 2132 |
3/10✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 12 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
12 | if (current_thd->is_error()) current_thd->clear_error(); |
| 2133 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | my_error(ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_REENCRYPT_LOG, MYF(0), |
| 2134 | error_message.c_str()); | ||
| 2135 | 12 | filename_list.clear(); | |
| 2136 | |||
| 2137 | 12 | return true; | |
| 2138 | 77 | } | |
| 2139 | |||
| 2140 | 2590897 | bool binlog_cache_data::compress(THD *thd) { | |
| 2141 |
1/2✓ Branch 0 taken 2591159 times.
✗ Branch 1 not taken.
|
2590897 | DBUG_TRACE; |
| 2142 | 2591159 | auto error{false}; | |
| 2143 | 2591159 | auto ctype{binary_log::transaction::compression::type::NONE}; | |
| 2144 |
1/2✓ Branch 0 taken 2591137 times.
✗ Branch 1 not taken.
|
2591159 | auto uncompressed_size{m_cache.length()}; |
| 2145 | 2591137 | auto size{uncompressed_size}; | |
| 2146 | 2591137 | auto &cctx{thd->rpl_thd_ctx.transaction_compression_ctx()}; | |
| 2147 | 2591001 | binary_log::transaction::compression::Compressor *compressor{nullptr}; | |
| 2148 | |||
| 2149 | // no compression enabled (ctype == NONE at this point) | ||
| 2150 |
2/2✓ Branch 0 taken 2590914 times.
✓ Branch 1 taken 87 times.
|
2591001 | if (thd->variables.binlog_trx_compression == false) goto end; |
| 2151 | |||
| 2152 | // do not compress if there are incident events | ||
| 2153 |
3/4✓ Branch 0 taken 165 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 163 times.
|
87 | DBUG_EXECUTE_IF("binlog_compression_inject_incident", set_incident();); |
| 2154 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 163 times.
|
165 | if (has_incident()) goto end; |
| 2155 | |||
| 2156 | // do not compress if there are non-transactional changes | ||
| 2157 | 163 | if (thd->get_transaction()->has_modified_non_trans_table( | |
| 2158 |
6/6✓ Branch 0 taken 156 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 155 times.
✓ Branch 4 taken 8 times.
✓ Branch 5 taken 155 times.
|
319 | Transaction_ctx::STMT) || |
| 2159 | 156 | thd->get_transaction()->has_modified_non_trans_table( | |
| 2160 | Transaction_ctx::SESSION)) | ||
| 2161 | 8 | goto end; | |
| 2162 | |||
| 2163 | // do not compress if has SBR | ||
| 2164 |
2/2✓ Branch 0 taken 95 times.
✓ Branch 1 taken 60 times.
|
155 | if (may_have_sbr_stmts()) goto end; |
| 2165 | |||
| 2166 | // Unable to get a reference to a compressor, fallback to | ||
| 2167 | // non compressed | ||
| 2168 |
2/4✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 60 times.
|
60 | if ((compressor = cctx.get_compressor(thd)) == nullptr) goto end; |
| 2169 | |||
| 2170 | // compression is enabled and all pre-conditions checked. | ||
| 2171 | // now compress | ||
| 2172 | else { | ||
| 2173 | 60 | std::size_t old_capacity{0}; | |
| 2174 | 60 | unsigned char *buffer{nullptr}; | |
| 2175 | 60 | unsigned char *old_buffer{nullptr}; | |
| 2176 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | Transaction_payload_log_event tple{thd}; |
| 2177 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | Compressed_ostream stream; |
| 2178 | 60 | PSI_stage_info old_stage; | |
| 2179 | |||
| 2180 | // set the thread stage to compressing transaction | ||
| 2181 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | thd->enter_stage(&stage_binlog_transaction_compress, &old_stage, __func__, |
| 2182 | __FILE__, __LINE__); | ||
| 2183 | // do we have enough compression buffer ? If not swap with a larger one | ||
| 2184 |
2/4✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✗ Branch 3 not taken.
|
60 | std::tie(buffer, std::ignore, old_capacity) = compressor->get_buffer(); |
| 2185 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 28 times.
|
60 | if (old_capacity < size) { |
| 2186 | 32 | old_buffer = buffer; | |
| 2187 | 32 | auto new_buffer = (unsigned char *)malloc(size); | |
| 2188 |
1/2✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
|
32 | if (new_buffer) |
| 2189 |
1/2✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
|
32 | compressor->set_buffer(new_buffer, size); |
| 2190 | else { | ||
| 2191 | /* purecov: begin inspected */ | ||
| 2192 | // OOM | ||
| 2193 | ✗ | error = true; | |
| 2194 | ✗ | goto compression_end; | |
| 2195 | /* purecov: end */ | ||
| 2196 | } | ||
| 2197 | } | ||
| 2198 | |||
| 2199 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | ctype = compressor->compression_type_code(); |
| 2200 | |||
| 2201 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | compressor->open(); |
| 2202 | |||
| 2203 | // inject the compressor in the output stream | ||
| 2204 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | stream.set_compressor(compressor); |
| 2205 | |||
| 2206 | // FIXME: innefficient, we should not copy caches around | ||
| 2207 | // This should be fixed when we revamp the capture | ||
| 2208 | // cache handling (and make this more geared towards | ||
| 2209 | // possible enhancements, such as streaming the changes) | ||
| 2210 | // Also, if the cache actually spills to disk, this may | ||
| 2211 | // the impact may be amplified, since reiniting the | ||
| 2212 | // causes a flush to disk | ||
| 2213 |
2/4✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 60 times.
|
60 | if ((error = m_cache.copy_to(&stream))) goto compression_end; |
| 2214 | |||
| 2215 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | compressor->close(); |
| 2216 | |||
| 2217 |
2/4✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 60 times.
|
60 | if ((error = m_cache.truncate(0))) goto compression_end; |
| 2218 | // Since we deleted all events from the cache, we also need to | ||
| 2219 | // reset event_counter. | ||
| 2220 | 60 | event_counter = 0; | |
| 2221 | |||
| 2222 | // fill in the new transport event | ||
| 2223 |
2/4✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✗ Branch 3 not taken.
|
60 | std::tie(buffer, size, std::ignore) = compressor->get_buffer(); |
| 2224 | 60 | tple.set_payload((const char *)buffer); | |
| 2225 | 60 | tple.set_payload_size(size); | |
| 2226 | 60 | tple.set_compression_type(ctype); | |
| 2227 | 60 | tple.set_uncompressed_size(uncompressed_size); | |
| 2228 | |||
| 2229 | // write back the new cache contents | ||
| 2230 |
1/2✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
|
60 | error = write_event(&tple); |
| 2231 | |||
| 2232 | 60 | compression_end: | |
| 2233 | // revert back to the default buffer, so that we don't overuse memory | ||
| 2234 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 28 times.
|
60 | if (old_buffer) { |
| 2235 |
2/4✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
✗ Branch 3 not taken.
|
32 | std::tie(buffer, std::ignore, std::ignore) = compressor->get_buffer(); |
| 2236 |
1/2✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
|
32 | compressor->set_buffer(old_buffer, old_capacity); |
| 2237 | 32 | free(buffer); | |
| 2238 | } | ||
| 2239 | |||
| 2240 | // revert the stage if needed | ||
| 2241 |
2/4✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✗ Branch 3 not taken.
|
60 | if (old_stage.m_key != 0) THD_STAGE_INFO(thd, old_stage); |
| 2242 | 60 | } | |
| 2243 | |||
| 2244 | 2591079 | end: | |
| 2245 |
2/2✓ Branch 0 taken 2590897 times.
✓ Branch 1 taken 182 times.
|
2591079 | if (!error) { |
| 2246 | 2590897 | set_compression_type(ctype); | |
| 2247 |
1/2✓ Branch 0 taken 2591053 times.
✗ Branch 1 not taken.
|
2590970 | set_compressed_size(m_cache.length()); |
| 2248 | 2591041 | set_decompressed_size(uncompressed_size); | |
| 2249 | } | ||
| 2250 | 2591189 | return error; | |
| 2251 | 2591233 | } | |
| 2252 | |||
| 2253 | /** | ||
| 2254 | This function finalizes the cache preparing for commit or rollback. | ||
| 2255 | |||
| 2256 | The function just writes all the necessary events to the cache but | ||
| 2257 | does not flush the data to the binary log file. That is the role of | ||
| 2258 | the binlog_cache_data::flush function. | ||
| 2259 | |||
| 2260 | @see binlog_cache_data::flush | ||
| 2261 | |||
| 2262 | @param thd The thread whose transaction should be flushed | ||
| 2263 | @param end_event The end event either commit/rollback | ||
| 2264 | |||
| 2265 | @return | ||
| 2266 | nonzero if an error pops up when flushing the cache. | ||
| 2267 | */ | ||
| 2268 | 2590839 | int binlog_cache_data::finalize(THD *thd, Log_event *end_event) { | |
| 2269 |
1/2✓ Branch 0 taken 2591171 times.
✗ Branch 1 not taken.
|
2590839 | DBUG_TRACE; |
| 2270 |
2/4✓ Branch 0 taken 2591177 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2591181 times.
✗ Branch 3 not taken.
|
2591171 | if (!is_binlog_empty()) { |
| 2271 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2591181 times.
|
2591181 | assert(!flags.finalized); |
| 2272 |
2/4✓ Branch 0 taken 2590891 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2590891 times.
|
2591181 | if (int error = flush_pending_event(thd)) return error; |
| 2273 |
2/4✓ Branch 0 taken 2591191 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2591191 times.
|
2590891 | if (int error = write_event(end_event)) return error; |
| 2274 |
2/4✓ Branch 0 taken 2591143 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2591143 times.
|
2591191 | if (int error = this->compress(thd)) return error; |
| 2275 |
6/10✓ Branch 0 taken 2591123 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2591152 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 2591041 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 111 times.
✓ Branch 8 taken 115 times.
✗ Branch 9 not taken.
|
2591143 | DBUG_PRINT("debug", ("flags.finalized: %s", YESNO(flags.finalized))); |
| 2276 | 2591156 | flags.finalized = true; | |
| 2277 | } | ||
| 2278 | 2591152 | return 0; | |
| 2279 | 2591152 | } | |
| 2280 | |||
| 2281 | /** | ||
| 2282 | The method writes XA END query to XA-prepared transaction's cache | ||
| 2283 | and calls the "basic" finalize(). | ||
| 2284 | |||
| 2285 | @return error code, 0 success | ||
| 2286 | */ | ||
| 2287 | |||
| 2288 | 638 | int binlog_cache_data::finalize(THD *thd, Log_event *end_event, XID_STATE *xs) { | |
| 2289 | 638 | int error = 0; | |
| 2290 | char buf[XID::ser_buf_size]; | ||
| 2291 | char query[sizeof("XA END") + 1 + sizeof(buf)]; | ||
| 2292 | 638 | int qlen = sprintf(query, "XA END %s", xs->get_xid()->serialize(buf)); | |
| 2293 |
1/2✓ Branch 0 taken 638 times.
✗ Branch 1 not taken.
|
638 | Query_log_event qev(thd, query, qlen, true, false, true, 0); |
| 2294 | |||
| 2295 |
2/4✓ Branch 0 taken 638 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 638 times.
|
638 | if ((error = write_event(&qev))) return error; |
| 2296 | |||
| 2297 |
1/2✓ Branch 0 taken 638 times.
✗ Branch 1 not taken.
|
638 | return finalize(thd, end_event); |
| 2298 | 638 | } | |
| 2299 | |||
| 2300 | /** | ||
| 2301 | Flush caches to the binary log. | ||
| 2302 | |||
| 2303 | If the cache is finalized, the cache will be flushed to the binary | ||
| 2304 | log file. If the cache is not finalized, nothing will be done. | ||
| 2305 | |||
| 2306 | If flushing fails for any reason, an error will be reported and the | ||
| 2307 | cache will be reset. Flushing can fail in two circumstances: | ||
| 2308 | |||
| 2309 | - It was not possible to write the cache to the file. In this case, | ||
| 2310 | it does not make sense to keep the cache. | ||
| 2311 | |||
| 2312 | - The cache was successfully written to disk but post-flush actions | ||
| 2313 | (such as binary log rotation) failed. In this case, the cache is | ||
| 2314 | already written to disk and there is no reason to keep it. | ||
| 2315 | |||
| 2316 | @see binlog_cache_data::finalize | ||
| 2317 | */ | ||
| 2318 | 5170646 | int binlog_cache_data::flush(THD *thd, my_off_t *bytes_written, | |
| 2319 | bool *wrote_xid) { | ||
| 2320 | /* | ||
| 2321 | Doing a commit or a rollback including non-transactional tables, | ||
| 2322 | i.e., ending a transaction where we might write the transaction | ||
| 2323 | cache to the binary log. | ||
| 2324 | |||
| 2325 | We can always end the statement when ending a transaction since | ||
| 2326 | transactions are not allowed inside stored functions. If they | ||
| 2327 | were, we would have to ensure that we're not ending a statement | ||
| 2328 | inside a stored function. | ||
| 2329 | */ | ||
| 2330 |
1/2✓ Branch 0 taken 5170646 times.
✗ Branch 1 not taken.
|
5170646 | DBUG_TRACE; |
| 2331 |
7/10✓ Branch 0 taken 5170646 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5170646 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 221 times.
✓ Branch 5 taken 5170425 times.
✓ Branch 6 taken 111 times.
✓ Branch 7 taken 110 times.
✓ Branch 8 taken 221 times.
✗ Branch 9 not taken.
|
5170646 | DBUG_PRINT("debug", ("flags.finalized: %s", YESNO(flags.finalized))); |
| 2332 | 5170646 | int error = 0; | |
| 2333 |
2/2✓ Branch 0 taken 2590143 times.
✓ Branch 1 taken 2580503 times.
|
5170646 | if (flags.finalized) { |
| 2334 |
1/2✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
|
2590143 | my_off_t bytes_in_cache = m_cache.length(); |
| 2335 | 2590143 | Transaction_ctx *trn_ctx = thd->get_transaction(); | |
| 2336 | |||
| 2337 |
5/8✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590143 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 2590032 times.
✓ Branch 6 taken 111 times.
✗ Branch 7 not taken.
|
2590143 | DBUG_PRINT("debug", ("bytes_in_cache: %llu", bytes_in_cache)); |
| 2338 | |||
| 2339 |
1/2✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
|
2590143 | trn_ctx->sequence_number = mysql_bin_log.m_dependency_tracker.step(); |
| 2340 | |||
| 2341 | /* | ||
| 2342 | In case of two caches the transaction is split into two groups. | ||
| 2343 | The 2nd group is considered to be a successor of the 1st rather | ||
| 2344 | than to have a common commit parent with it. | ||
| 2345 | Notice that due to a simple method of detection that the current is | ||
| 2346 | the 2nd cache being flushed, the very first few transactions may be logged | ||
| 2347 | sequentially (a next one is tagged as if a preceding one is its | ||
| 2348 | commit parent). | ||
| 2349 | */ | ||
| 2350 |
2/2✓ Branch 0 taken 71022 times.
✓ Branch 1 taken 2519121 times.
|
2590143 | if (trn_ctx->last_committed == SEQ_UNINIT) |
| 2351 | 71022 | trn_ctx->last_committed = trn_ctx->sequence_number - 1; | |
| 2352 | |||
| 2353 | /* | ||
| 2354 | The GTID is written prior to flushing the statement cache, if | ||
| 2355 | the transaction has written to the statement cache; and prior to | ||
| 2356 | flushing the transaction cache if the transaction has written to | ||
| 2357 | the transaction cache. If GTIDs are enabled, then transactional | ||
| 2358 | and non-transactional updates cannot be mixed, so at most one of | ||
| 2359 | the caches can be non-empty, so just one GTID will be | ||
| 2360 | generated. If GTIDs are disabled, then no GTID is generated at | ||
| 2361 | all; if both the transactional cache and the statement cache are | ||
| 2362 | non-empty then we get two Anonymous_gtid_log_events, which is | ||
| 2363 | correct. | ||
| 2364 | */ | ||
| 2365 |
1/2✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
|
2590143 | Binlog_event_writer writer(mysql_bin_log.get_binlog_file(), thd); |
| 2366 | |||
| 2367 | /* The GTID ownership process might set the commit_error */ | ||
| 2368 |
1/2✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
|
5180286 | error = (thd->commit_error == THD::CE_FLUSH_ERROR || |
| 2369 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2590142 times.
|
2590143 | thd->commit_error == THD::CE_FLUSH_GNO_EXHAUSTED_ERROR); |
| 2370 | |||
| 2371 |
5/6✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29940 times.
✓ Branch 3 taken 2560203 times.
✓ Branch 4 taken 9946 times.
✓ Branch 5 taken 19994 times.
|
2590143 | DBUG_EXECUTE_IF("simulate_binlog_flush_error", { |
| 2372 | if (rand() % 3 == 0) { | ||
| 2373 | thd->commit_error = THD::CE_FLUSH_ERROR; | ||
| 2374 | } | ||
| 2375 | };); | ||
| 2376 | |||
| 2377 |
4/6✓ Branch 0 taken 2590143 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2590142 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
2590143 | DBUG_EXECUTE_IF("fault_injection_reinit_io_cache_while_flushing_to_file", |
| 2378 | { DBUG_SET("+d,fault_injection_reinit_io_cache"); }); | ||
| 2379 | |||
| 2380 |
2/2✓ Branch 0 taken 2590142 times.
✓ Branch 1 taken 1 times.
|
2590143 | if (!error) |
| 2381 |
3/4✓ Branch 0 taken 2590139 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2590136 times.
|
2590142 | if ((error = mysql_bin_log.write_transaction(thd, this, &writer))) |
| 2382 | 3 | thd->commit_error = THD::CE_FLUSH_ERROR; | |
| 2383 | |||
| 2384 |
4/6✓ Branch 0 taken 2590140 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2590139 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
2590140 | DBUG_EXECUTE_IF("fault_injection_reinit_io_cache_while_flushing_to_file", |
| 2385 | { DBUG_SET("-d,fault_injection_reinit_io_cache"); }); | ||
| 2386 | |||
| 2387 |
4/4✓ Branch 0 taken 2039492 times.
✓ Branch 1 taken 550648 times.
✓ Branch 2 taken 2039489 times.
✓ Branch 3 taken 3 times.
|
2590140 | if (flags.with_xid && error == 0) *wrote_xid = true; |
| 2388 | |||
| 2389 | /* | ||
| 2390 | Reset have to be after the if above, since it clears the | ||
| 2391 | with_xid flag | ||
| 2392 | */ | ||
| 2393 |
1/2✓ Branch 0 taken 2590140 times.
✗ Branch 1 not taken.
|
2590140 | reset(); |
| 2394 |
1/2✓ Branch 0 taken 2590140 times.
✗ Branch 1 not taken.
|
2590140 | if (bytes_written) *bytes_written = bytes_in_cache; |
| 2395 | 2590140 | } | |
| 2396 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5170643 times.
|
5170643 | assert(!flags.finalized); |
| 2397 | 5170643 | return error; | |
| 2398 | 5170643 | } | |
| 2399 | |||
| 2400 | /** | ||
| 2401 | This function truncates the transactional cache upon committing or rolling | ||
| 2402 | back either a transaction or a statement. | ||
| 2403 | |||
| 2404 | @param thd The thread whose transaction should be flushed | ||
| 2405 | @param all @c true means truncate the transaction, otherwise the | ||
| 2406 | statement must be truncated. | ||
| 2407 | |||
| 2408 | @return | ||
| 2409 | nonzero if an error pops up when truncating the transactional cache. | ||
| 2410 | */ | ||
| 2411 | 8941 | int binlog_trx_cache_data::truncate(THD *thd, bool all) { | |
| 2412 |
1/2✓ Branch 0 taken 8951 times.
✗ Branch 1 not taken.
|
8941 | DBUG_TRACE; |
| 2413 | 8951 | int error = 0; | |
| 2414 | |||
| 2415 |
3/14✓ Branch 0 taken 8951 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8951 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 8951 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
8951 | DBUG_PRINT("info", |
| 2416 | ("thd->options={ %s %s}, transaction: %s", | ||
| 2417 | FLAGSTR(thd->variables.option_bits, OPTION_NOT_AUTOCOMMIT), | ||
| 2418 | FLAGSTR(thd->variables.option_bits, OPTION_BEGIN), | ||
| 2419 | all ? "all" : "stmt")); | ||
| 2420 | |||
| 2421 |
1/2✓ Branch 0 taken 8945 times.
✗ Branch 1 not taken.
|
8951 | remove_pending_event(); |
| 2422 | |||
| 2423 | /* | ||
| 2424 | If rolling back an entire transaction or a single statement not | ||
| 2425 | inside a transaction, we reset the transaction cache. | ||
| 2426 | Even though formally the atomic DDL statement may not end multi-statement | ||
| 2427 | transaction the cache needs full resetting as there must | ||
| 2428 | be no other data in it but belonging to the DDL. | ||
| 2429 | */ | ||
| 2430 |
3/4✓ Branch 0 taken 8943 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4718 times.
✓ Branch 3 taken 4225 times.
|
8945 | if (ending_trans(thd, all)) { |
| 2431 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4717 times.
|
4718 | if (has_incident()) { |
| 2432 | 2 | const char *err_msg = | |
| 2433 | "Error happend while resetting the transaction " | ||
| 2434 | "cache for a rolled back transaction or a single " | ||
| 2435 | "statement not inside a transaction."; | ||
| 2436 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | error = mysql_bin_log.write_incident(thd, true /*need_lock_log=true*/, |
| 2437 | err_msg); | ||
| 2438 | } | ||
| 2439 |
1/2✓ Branch 0 taken 4719 times.
✗ Branch 1 not taken.
|
4719 | reset(); |
| 2440 | } | ||
| 2441 | /* | ||
| 2442 | If rolling back a statement in a transaction, we truncate the | ||
| 2443 | transaction cache to remove the statement. | ||
| 2444 | */ | ||
| 2445 |
2/2✓ Branch 0 taken 1242 times.
✓ Branch 1 taken 2982 times.
|
4225 | else if (get_prev_position() != MY_OFF_T_UNDEF) |
| 2446 |
1/2✓ Branch 0 taken 1242 times.
✗ Branch 1 not taken.
|
1242 | restore_prev_position(); |
| 2447 | |||
| 2448 | 8943 | thd->clear_binlog_table_maps(); | |
| 2449 | |||
| 2450 | 8950 | return error; | |
| 2451 | 8945 | } | |
| 2452 | |||
| 2453 | 2101893 | inline enum xa_option_words get_xa_opt(THD *thd) { | |
| 2454 | 2101893 | enum xa_option_words xa_opt = XA_NONE; | |
| 2455 |
2/2✓ Branch 0 taken 1188 times.
✓ Branch 1 taken 2100705 times.
|
2101893 | switch (thd->lex->sql_command) { |
| 2456 | 1188 | case SQLCOM_XA_COMMIT: | |
| 2457 | xa_opt = | ||
| 2458 | 1188 | static_cast<Sql_cmd_xa_commit *>(thd->lex->m_sql_cmd)->get_xa_opt(); | |
| 2459 | 1188 | break; | |
| 2460 | 2100705 | default: | |
| 2461 | 2100705 | break; | |
| 2462 | } | ||
| 2463 | |||
| 2464 | 2101893 | return xa_opt; | |
| 2465 | } | ||
| 2466 | |||
| 2467 | /** | ||
| 2468 | Predicate function yields true when XA transaction is | ||
| 2469 | being logged having a proper state ready for prepare or | ||
| 2470 | commit in one phase. | ||
| 2471 | |||
| 2472 | @param thd THD pointer of running transaction | ||
| 2473 | @return true When the being prepared transaction should be binlogged, | ||
| 2474 | false otherwise. | ||
| 2475 | */ | ||
| 2476 | |||
| 2477 | 35853195 | inline bool is_loggable_xa_prepare(THD *thd) { | |
| 2478 | /* | ||
| 2479 | simulate_commit_failure is doing a trick with XID_STATE while | ||
| 2480 | the ongoing transaction is not XA, and therefore to be errored out, | ||
| 2481 | asserted below. In that case because of the | ||
| 2482 | latter fact the function returns @c false. | ||
| 2483 | */ | ||
| 2484 |
1/8✗ Branch 0 not taken.
✓ Branch 1 taken 35853653 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
35853195 | DBUG_EXECUTE_IF("simulate_commit_failure", { |
| 2485 | XID_STATE *xs = thd->get_transaction()->xid_state(); | ||
| 2486 | assert((thd->is_error() && xs->get_state() == XID_STATE::XA_IDLE) || | ||
| 2487 | xs->get_state() == XID_STATE::XA_NOTR); | ||
| 2488 | }); | ||
| 2489 | |||
| 2490 |
3/4✓ Branch 0 taken 35854350 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2477 times.
✓ Branch 3 taken 35852580 times.
|
35853653 | return DBUG_EVALUATE_IF( |
| 2491 | "simulate_commit_failure", false, | ||
| 2492 | thd->get_transaction()->xid_state()->has_state(XID_STATE::XA_IDLE)); | ||
| 2493 | } | ||
| 2494 | |||
| 2495 | 4974099 | static int binlog_prepare(handlerton *, THD *thd, bool all) { | |
| 2496 |
1/2✓ Branch 0 taken 4974180 times.
✗ Branch 1 not taken.
|
4974099 | DBUG_TRACE; |
| 2497 |
2/2✓ Branch 0 taken 4437490 times.
✓ Branch 1 taken 536690 times.
|
4974180 | if (!all) { |
| 2498 |
1/2✓ Branch 0 taken 4437429 times.
✗ Branch 1 not taken.
|
4437490 | thd->get_transaction()->store_commit_parent( |
| 2499 | mysql_bin_log.m_dependency_tracker.get_max_committed_timestamp()); | ||
| 2500 | } | ||
| 2501 | 4974189 | return 0; | |
| 2502 | 4974113 | } | |
| 2503 | |||
| 2504 | 530 | static int binlog_set_prepared_in_tc(handlerton *, THD *) { return 0; } | |
| 2505 | |||
| 2506 | /** | ||
| 2507 | Logging XA commit/rollback of a prepared transaction in the case | ||
| 2508 | it was disconnected and resumed (recovered), or executed by a slave applier. | ||
| 2509 | |||
| 2510 | @param thd THD handle | ||
| 2511 | @param xid a pointer to XID object | ||
| 2512 | @param commit when @c true XA-COMMIT is logged, otherwise XA-ROLLBACK | ||
| 2513 | |||
| 2514 | @return error code, 0 success | ||
| 2515 | */ | ||
| 2516 | 1325 | int MYSQL_BIN_LOG::write_xa_to_cache(THD *thd) { | |
| 2517 |
3/4✓ Branch 0 taken 239 times.
✓ Branch 1 taken 1086 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 239 times.
|
1325 | assert(thd->lex->sql_command == SQLCOM_XA_COMMIT || |
| 2518 | thd->lex->sql_command == SQLCOM_XA_ROLLBACK); | ||
| 2519 | |||
| 2520 |
3/4✓ Branch 0 taken 1325 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 194 times.
✓ Branch 3 taken 1131 times.
|
1325 | if (get_xa_opt(thd) == XA_ONE_PHASE) return 0; |
| 2521 | |||
| 2522 | 1131 | auto xid_state = thd->get_transaction()->xid_state(); | |
| 2523 |
2/2✓ Branch 0 taken 571 times.
✓ Branch 1 taken 560 times.
|
1131 | if (!xid_state->is_binlogged()) |
| 2524 | 571 | return 0; // nothing was really logged at prepare | |
| 2525 | |||
| 2526 |
7/10✓ Branch 0 taken 560 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 558 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✓ Branch 9 taken 558 times.
|
560 | if (thd->is_error() && DBUG_EVALUATE_IF("simulate_xa_rm_error", 0, 1)) |
| 2527 | 2 | return 0; // don't binlog if there are some errors. | |
| 2528 | |||
| 2529 | 558 | auto xid_to_write = xid_state->get_xid(); | |
| 2530 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 558 times.
|
558 | assert(xid_to_write != nullptr); |
| 2531 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 558 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
558 | assert(!xid_to_write->is_null() || |
| 2532 | !(thd->variables.option_bits & OPTION_BIN_LOG)); | ||
| 2533 | |||
| 2534 |
1/2✓ Branch 0 taken 558 times.
✗ Branch 1 not taken.
|
558 | std::ostringstream oss; |
| 2535 | oss << "XA " | ||
| 2536 | 558 | << (thd->lex->sql_command == SQLCOM_XA_COMMIT ? "COMMIT" : "ROLLBACK") | |
| 2537 |
7/12✓ Branch 0 taken 558 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 412 times.
✓ Branch 3 taken 146 times.
✓ Branch 4 taken 558 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 558 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 558 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 558 times.
✗ Branch 11 not taken.
|
558 | << " " << *xid_to_write << std::flush; |
| 2538 |
1/2✓ Branch 0 taken 558 times.
✗ Branch 1 not taken.
|
558 | auto query = oss.str(); |
| 2539 | 558 | Query_log_event qinfo(thd, query.data(), query.length(), false, true, true, 0, | |
| 2540 |
1/2✓ Branch 0 taken 558 times.
✗ Branch 1 not taken.
|
1116 | false); |
| 2541 |
1/2✓ Branch 0 taken 558 times.
✗ Branch 1 not taken.
|
558 | return this->write_event(&qinfo); |
| 2542 | 558 | } | |
| 2543 | |||
| 2544 | 55 | static int binlog_start_consistent_snapshot(handlerton *hton, THD *thd) { | |
| 2545 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | DBUG_ENTER("binlog_start_consistent_snapshot"); |
| 2546 | |||
| 2547 | #ifdef WITH_WSREP | ||
| 2548 | /* If operating in emulation binlog mode avoid binlog snapshot as | ||
| 2549 | binlog is not open. */ | ||
| 2550 |
6/12✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 54 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 1 times.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
55 | if (WSREP_EMULATE_BINLOG(thd)) DBUG_RETURN(0); |
| 2551 | #endif /* WITH_WSREP */ | ||
| 2552 | |||
| 2553 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | int err = thd->binlog_setup_trx_data(); |
| 2554 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
55 | if (err) DBUG_RETURN(err); |
| 2555 | |||
| 2556 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); |
| 2557 | |||
| 2558 | /* Server layer calls us with LOCK_log locked, so this is safe. */ | ||
| 2559 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | mysql_bin_log.raw_get_current_log(&cache_mngr->binlog_info); |
| 2560 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | gtid_state->get_snapshot_gtid_executed(cache_mngr->snapshot_gtid_executed); |
| 2561 | |||
| 2562 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | trans_register_ha(thd, true, hton, nullptr); |
| 2563 | |||
| 2564 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | DBUG_RETURN(err); |
| 2565 | } | ||
| 2566 | |||
| 2567 | 21 | static int binlog_clone_consistent_snapshot(handlerton *hton, THD *thd, | |
| 2568 | THD *from_thd) { | ||
| 2569 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | DBUG_ENTER("binlog_start_consistent_snapshot"); |
| 2570 | |||
| 2571 | #ifdef WITH_WSREP | ||
| 2572 | /* If operating in emulation binlog mode avoid binlog snapshot as | ||
| 2573 | binlog is not open. */ | ||
| 2574 |
2/12✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 21 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
21 | if (WSREP_EMULATE_BINLOG(thd)) DBUG_RETURN(0); |
| 2575 | #endif /* WITH_WSREP */ | ||
| 2576 | |||
| 2577 | const binlog_cache_mngr *from_cache_mngr = | ||
| 2578 | opt_bin_log | ||
| 2579 |
2/4✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
|
21 | ? static_cast<binlog_cache_mngr *>(thd_get_cache_mngr(from_thd)) |
| 2580 | 21 | : nullptr; | |
| 2581 | |||
| 2582 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | if (from_cache_mngr == nullptr) { |
| 2583 | ✗ | push_warning_printf(thd, Sql_condition::SL_WARNING, HA_ERR_UNSUPPORTED, | |
| 2584 | "WITH CONSISTENT SNAPSHOT FROM SESSION was ignored for " | ||
| 2585 | "binary log, because the specified session does not " | ||
| 2586 | "have a consistent snapshot of binary log " | ||
| 2587 | "coordinates."); | ||
| 2588 | ✗ | DBUG_RETURN(0); | |
| 2589 | } | ||
| 2590 | |||
| 2591 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | int err = thd->binlog_setup_trx_data(); |
| 2592 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
21 | if (err) DBUG_RETURN(err); |
| 2593 | |||
| 2594 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); |
| 2595 | |||
| 2596 | 21 | const my_off_t pos = from_cache_mngr->binlog_info.pos; | |
| 2597 | char log_file_name[FN_REFLEN]; | ||
| 2598 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | strmake(log_file_name, from_cache_mngr->binlog_info.log_file_name, |
| 2599 | sizeof(log_file_name) - 1); | ||
| 2600 | |||
| 2601 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | mysql_mutex_lock(&thd->LOCK_thd_data); |
| 2602 | |||
| 2603 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | cache_mngr->snapshot_gtid_executed = from_cache_mngr->snapshot_gtid_executed; |
| 2604 | 21 | cache_mngr->binlog_info.pos = pos; | |
| 2605 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | strmake(cache_mngr->binlog_info.log_file_name, log_file_name, |
| 2606 | sizeof(cache_mngr->binlog_info.log_file_name) - 1); | ||
| 2607 | |||
| 2608 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | mysql_mutex_unlock(&thd->LOCK_thd_data); |
| 2609 | |||
| 2610 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | trans_register_ha(thd, true, hton, nullptr); |
| 2611 | |||
| 2612 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | DBUG_RETURN(err); |
| 2613 | } | ||
| 2614 | |||
| 2615 | /** | ||
| 2616 | When a fatal error occurs due to which binary logging becomes impossible and | ||
| 2617 | the user specified binlog_error_action= ABORT_SERVER the following function is | ||
| 2618 | invoked. This function pushes the appropriate error message to client and logs | ||
| 2619 | the same to server error log and then aborts the server. | ||
| 2620 | |||
| 2621 | @param err_string Error string which specifies the exact error | ||
| 2622 | message from the caller. | ||
| 2623 | */ | ||
| 2624 | ✗ | static void exec_binlog_error_action_abort(const char *err_string) { | |
| 2625 | ✗ | THD *thd = current_thd; | |
| 2626 | /* | ||
| 2627 | When the code enters here it means that there was an error at higher layer | ||
| 2628 | and my_error function could have been invoked to let the client know what | ||
| 2629 | went wrong during the execution. | ||
| 2630 | |||
| 2631 | But these errors will not let the client know that the server is going to | ||
| 2632 | abort. Even if we add an additional my_error function call at this point | ||
| 2633 | client will be able to see only the first error message that was set | ||
| 2634 | during the very first invocation of my_error function call. | ||
| 2635 | |||
| 2636 | The advantage of having multiple my_error function calls are visible when | ||
| 2637 | the server is up and running and user issues SHOW WARNINGS or SHOW ERROR | ||
| 2638 | calls. In this special scenario server will be immediately aborted and | ||
| 2639 | user will not be able execute the above SHOW commands. | ||
| 2640 | |||
| 2641 | Hence we clear the previous errors and push one critical error message to | ||
| 2642 | clients. | ||
| 2643 | */ | ||
| 2644 | ✗ | if (thd) { | |
| 2645 | ✗ | if (thd->is_error()) thd->clear_error(); | |
| 2646 | /* | ||
| 2647 | Send error to both client and to the server error log. | ||
| 2648 | */ | ||
| 2649 | ✗ | my_error(ER_BINLOG_LOGGING_IMPOSSIBLE, MYF(ME_FATALERROR), err_string); | |
| 2650 | } | ||
| 2651 | |||
| 2652 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_LOGGING_NOT_POSSIBLE, err_string); | |
| 2653 | ✗ | flush_error_log_messages(); | |
| 2654 | |||
| 2655 | ✗ | if (thd) thd->send_statement_status(); | |
| 2656 | ✗ | my_abort(); | |
| 2657 | } | ||
| 2658 | |||
| 2659 | /** | ||
| 2660 | This function is called once after each statement. | ||
| 2661 | |||
| 2662 | @todo This function is currently not used any more and will | ||
| 2663 | eventually be eliminated. The real commit job is done in the | ||
| 2664 | MYSQL_BIN_LOG::commit function. | ||
| 2665 | |||
| 2666 | @see MYSQL_BIN_LOG::commit | ||
| 2667 | |||
| 2668 | @see handlerton::commit | ||
| 2669 | */ | ||
| 2670 | 5461006 | static int binlog_commit(handlerton *, THD *, bool) { | |
| 2671 |
1/2✓ Branch 0 taken 5461106 times.
✗ Branch 1 not taken.
|
5461006 | DBUG_TRACE; |
| 2672 | /* | ||
| 2673 | Nothing to do (any more) on commit. | ||
| 2674 | */ | ||
| 2675 | 5461122 | return 0; | |
| 2676 | 5461106 | } | |
| 2677 | |||
| 2678 | /** | ||
| 2679 | This function is called when a transaction or a statement is rolled back. | ||
| 2680 | |||
| 2681 | @internal It is necessary to execute a rollback here if the | ||
| 2682 | transaction was rolled back because of executing a ROLLBACK TO | ||
| 2683 | SAVEPOINT command, but it is not used for normal rollback since | ||
| 2684 | MYSQL_BIN_LOG::rollback is called in that case. | ||
| 2685 | |||
| 2686 | @todo Refactor code to introduce a <code>MYSQL_BIN_LOG::rollback(THD | ||
| 2687 | *thd, SAVEPOINT *sv)</code> function in @c TC_LOG and have that | ||
| 2688 | function execute the necessary work to rollback to a savepoint. | ||
| 2689 | |||
| 2690 | @param thd The client thread that executes the transaction. | ||
| 2691 | @param all This is @c true if this is a real transaction rollback, and | ||
| 2692 | @false otherwise. | ||
| 2693 | |||
| 2694 | @see handlerton::rollback | ||
| 2695 | */ | ||
| 2696 | 8015 | static int binlog_rollback(handlerton *, THD *thd, bool all) { | |
| 2697 |
1/2✓ Branch 0 taken 8017 times.
✗ Branch 1 not taken.
|
8015 | DBUG_TRACE; |
| 2698 | 8017 | int error = 0; | |
| 2699 | #ifdef WITH_WSREP | ||
| 2700 |
6/6✓ Branch 0 taken 34 times.
✓ Branch 1 taken 7983 times.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 33 times.
✓ Branch 5 taken 7984 times.
|
8051 | if (thd->lex->sql_command == SQLCOM_ROLLBACK_TO_SAVEPOINT && |
| 2701 | 34 | thd->wsrep_trx().state() != wsrep::transaction::s_aborting) | |
| 2702 | #else | ||
| 2703 | if (thd->lex->sql_command == SQLCOM_ROLLBACK_TO_SAVEPOINT) | ||
| 2704 | #endif /* WITH_WSREP */ | ||
| 2705 |
1/2✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
|
33 | error = mysql_bin_log.rollback(thd, all); |
| 2706 | 8016 | return error; | |
| 2707 | 8017 | } | |
| 2708 | |||
| 2709 | /** | ||
| 2710 | Write a rollback record of the transaction to the binary log. | ||
| 2711 | |||
| 2712 | For binary log group commit, the rollback is separated into three | ||
| 2713 | parts: | ||
| 2714 | |||
| 2715 | 1. First part consists of filling the necessary caches and | ||
| 2716 | finalizing them (if they need to be finalized). After a cache is | ||
| 2717 | finalized, nothing can be added to the cache. | ||
| 2718 | |||
| 2719 | 2. Second part execute an ordered flush and commit. This will be | ||
| 2720 | done using the group commit functionality in @c ordered_commit. | ||
| 2721 | |||
| 2722 | Since we roll back the transaction early, we call @c | ||
| 2723 | ordered_commit with the @c skip_commit flag set. The @c | ||
| 2724 | ha_commit_low call inside @c ordered_commit will then not be | ||
| 2725 | called. | ||
| 2726 | |||
| 2727 | 3. Third part checks any errors resulting from the flush and handles | ||
| 2728 | them appropriately. | ||
| 2729 | |||
| 2730 | @see MYSQL_BIN_LOG::ordered_commit | ||
| 2731 | @see ha_commit_low | ||
| 2732 | @see ha_rollback_low | ||
| 2733 | |||
| 2734 | @param thd Session to commit | ||
| 2735 | @param all This is @c true if this is a real transaction rollback, and | ||
| 2736 | @c false otherwise. | ||
| 2737 | |||
| 2738 | @return Error code, or zero if there were no error. | ||
| 2739 | */ | ||
| 2740 | |||
| 2741 | 1838813 | int MYSQL_BIN_LOG::rollback(THD *thd, bool all) { | |
| 2742 | 1838813 | int error = 0; | |
| 2743 | 1838813 | bool stuff_logged = false; | |
| 2744 |
1/2✓ Branch 0 taken 1839592 times.
✗ Branch 1 not taken.
|
1838813 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd); |
| 2745 | 1839592 | bool is_empty = false; | |
| 2746 | |||
| 2747 |
1/2✓ Branch 0 taken 1839568 times.
✗ Branch 1 not taken.
|
1839592 | DBUG_TRACE; |
| 2748 |
10/14✓ Branch 0 taken 1839570 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1839449 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 1839443 times.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✓ Branch 9 taken 2 times.
✓ Branch 10 taken 3 times.
✓ Branch 11 taken 3 times.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
|
1839568 | DBUG_PRINT("enter", |
| 2749 | ("all: %s, cache_mngr: 0x%llx, thd->is_error: %s", YESNO(all), | ||
| 2750 | (ulonglong)cache_mngr, YESNO(thd->is_error()))); | ||
| 2751 | /* | ||
| 2752 | Defer XA-transaction rollback until its XA-rollback event is recorded. | ||
| 2753 | When we are executing a ROLLBACK TO SAVEPOINT, we | ||
| 2754 | should only clear the caches since this function is called as part | ||
| 2755 | of the engine rollback. | ||
| 2756 | In other cases we roll back the transaction in the engines early | ||
| 2757 | since this will release locks and allow other transactions to | ||
| 2758 | start executing. | ||
| 2759 | */ | ||
| 2760 |
3/4✓ Branch 0 taken 1839404 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 239 times.
✓ Branch 3 taken 1839165 times.
|
1839449 | if (is_xa_rollback(thd)) { |
| 2761 | 239 | auto xs = thd->get_transaction()->xid_state(); | |
| 2762 | |||
| 2763 |
7/10✓ Branch 0 taken 27 times.
✓ Branch 1 taken 212 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 25 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
|
239 | assert(all || !xs->is_binlogged() || |
| 2764 | (!xs->is_detached() && thd->is_error())); | ||
| 2765 | |||
| 2766 | 239 | is_empty = !xs->is_binlogged(); | |
| 2767 | |||
| 2768 |
2/4✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 239 times.
|
239 | if ((error = this->write_xa_to_cache(thd)) != 0) goto end; |
| 2769 | |||
| 2770 |
1/2✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
|
239 | cache_mngr = thd_get_cache_mngr(thd); |
| 2771 | #ifdef WITH_WSREP | ||
| 2772 | /* | ||
| 2773 | BF aborted THD may have dandling sql_command set to | ||
| 2774 | SQLCOM_ROLLBACK_TO_SAVEPOINT, don't care about it, as we have to BF abort | ||
| 2775 | this one | ||
| 2776 | */ | ||
| 2777 | ✗ | } else if (thd->lex->sql_command != SQLCOM_ROLLBACK_TO_SAVEPOINT || | |
| 2778 |
3/4✓ Branch 0 taken 53 times.
✓ Branch 1 taken 1839112 times.
✓ Branch 2 taken 1839030 times.
✗ Branch 3 not taken.
|
1839055 | thd->wsrep_trx().state() == wsrep::transaction::s_aborting || |
| 2779 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 49 times.
|
53 | thd->wsrep_force_savept_rollback) { |
| 2780 | #else | ||
| 2781 | } else if (thd->lex->sql_command != SQLCOM_ROLLBACK_TO_SAVEPOINT) { | ||
| 2782 | #endif /* WITH_WSREP */ | ||
| 2783 | /* | ||
| 2784 | Reset binlog_snapshot_% variables for the current connection so that the | ||
| 2785 | current coordinates are shown after committing a consistent snapshot | ||
| 2786 | transaction. | ||
| 2787 | */ | ||
| 2788 |
2/2✓ Branch 0 taken 228354 times.
✓ Branch 1 taken 1610676 times.
|
1839030 | if (cache_mngr != nullptr) { |
| 2789 |
1/2✓ Branch 0 taken 228355 times.
✗ Branch 1 not taken.
|
228354 | mysql_mutex_lock(&thd->LOCK_thd_data); |
| 2790 | 228355 | cache_mngr->drop_consistent_snapshot(); | |
| 2791 |
1/2✓ Branch 0 taken 228417 times.
✗ Branch 1 not taken.
|
228380 | mysql_mutex_unlock(&thd->LOCK_thd_data); |
| 2792 | } | ||
| 2793 |
2/4✓ Branch 0 taken 1837928 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1837928 times.
|
1839093 | if ((error = trx_coordinator::rollback_in_engines(thd, all))) goto end; |
| 2794 | } | ||
| 2795 | |||
| 2796 | /* | ||
| 2797 | If there is no cache manager, or if there is nothing in the | ||
| 2798 | caches, there are no caches to roll back, so we're trivially done | ||
| 2799 | unless XA-ROLLBACK that yet to run rollback_low(). | ||
| 2800 | */ | ||
| 2801 |
7/8✓ Branch 0 taken 228551 times.
✓ Branch 1 taken 1609588 times.
✓ Branch 2 taken 228614 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 218995 times.
✓ Branch 5 taken 9619 times.
✓ Branch 6 taken 1828937 times.
✓ Branch 7 taken 9265 times.
|
1838139 | if (cache_mngr == nullptr || cache_mngr->is_binlog_empty()) { |
| 2802 | 1828937 | goto end; | |
| 2803 | } | ||
| 2804 | |||
| 2805 |
3/14✓ Branch 0 taken 9619 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9618 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9618 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
9265 | DBUG_PRINT("debug", ("all.cannot_safely_rollback(): %s, trx_cache_empty: %s", |
| 2806 | YESNO(thd->get_transaction()->cannot_safely_rollback( | ||
| 2807 | Transaction_ctx::SESSION)), | ||
| 2808 | YESNO(cache_mngr->trx_cache.is_binlog_empty()))); | ||
| 2809 |
3/14✓ Branch 0 taken 9617 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9619 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9619 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
9618 | DBUG_PRINT("debug", |
| 2810 | ("stmt.cannot_safely_rollback(): %s, stmt_cache_empty: %s", | ||
| 2811 | YESNO(thd->get_transaction()->cannot_safely_rollback( | ||
| 2812 | Transaction_ctx::STMT)), | ||
| 2813 | YESNO(cache_mngr->stmt_cache.is_binlog_empty()))); | ||
| 2814 | |||
| 2815 | /* | ||
| 2816 | If an incident event is set we do not flush the content of the statement | ||
| 2817 | cache because it may be corrupted. | ||
| 2818 | */ | ||
| 2819 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 9611 times.
|
9619 | if (cache_mngr->stmt_cache.has_incident()) { |
| 2820 | 7 | const char *err_msg = | |
| 2821 | "The content of the statement cache is corrupted " | ||
| 2822 | "while writing a rollback record of the transaction " | ||
| 2823 | "to the binary log."; | ||
| 2824 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | error = write_incident(thd, true /*need_lock_log=true*/, err_msg); |
| 2825 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | cache_mngr->stmt_cache.reset(); |
| 2826 |
3/4✓ Branch 0 taken 9612 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 825 times.
✓ Branch 3 taken 8787 times.
|
9611 | } else if (!cache_mngr->stmt_cache.is_binlog_empty()) { |
| 2827 | 1671 | if (thd->lex->sql_command == SQLCOM_CREATE_TABLE && | |
| 2828 |
2/4✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
|
21 | !thd->lex->query_block->field_list_is_empty() && /* With select */ |
| 2829 |
6/8✓ Branch 0 taken 21 times.
✓ Branch 1 taken 804 times.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 21 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 21 times.
✓ Branch 7 taken 804 times.
|
867 | !(thd->lex->create_info->options & HA_LEX_CREATE_TMP_TABLE) && |
| 2830 | 21 | thd->is_current_stmt_binlog_format_row()) { | |
| 2831 | /* | ||
| 2832 | In row based binlog format, we reset the binlog statement cache | ||
| 2833 | when rolling back a single statement 'CREATE...SELECT' transaction, | ||
| 2834 | since the 'CREATE TABLE' event was put in the binlog statement cache. | ||
| 2835 | */ | ||
| 2836 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | cache_mngr->stmt_cache.reset(); |
| 2837 | } else { | ||
| 2838 |
2/4✓ Branch 0 taken 804 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 804 times.
|
804 | if ((error = cache_mngr->stmt_cache.finalize(thd))) goto end; |
| 2839 | 804 | stuff_logged = true; | |
| 2840 | } | ||
| 2841 | } | ||
| 2842 | |||
| 2843 |
3/4✓ Branch 0 taken 9616 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5179 times.
✓ Branch 3 taken 4437 times.
|
9619 | if (ending_trans(thd, all)) { |
| 2844 |
3/4✓ Branch 0 taken 5178 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 482 times.
✓ Branch 3 taken 4696 times.
|
5179 | if (trans_cannot_safely_rollback(thd)) { |
| 2845 | 482 | auto xs = thd->get_transaction()->xid_state(); | |
| 2846 |
1/2✓ Branch 0 taken 482 times.
✗ Branch 1 not taken.
|
482 | std::string query{"ROLLBACK"}; |
| 2847 | |||
| 2848 |
2/4✓ Branch 0 taken 482 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 482 times.
|
482 | if (is_xa_rollback(thd)) { |
| 2849 | /* this block is relevant only for not prepared yet and "local" xa trx | ||
| 2850 | */ | ||
| 2851 | ✗ | assert( | |
| 2852 | thd->get_transaction()->xid_state()->has_state(XID_STATE::XA_IDLE)); | ||
| 2853 | |||
| 2854 | ✗ | std::ostringstream oss; | |
| 2855 | ✗ | oss << "XA ROLLBACK " << *xs->get_xid() << std::flush; | |
| 2856 | ✗ | query = oss.str(); | |
| 2857 | } | ||
| 2858 | /* | ||
| 2859 | If the transaction is being rolled back and contains changes that | ||
| 2860 | cannot be rolled back, the trx-cache's content is flushed. | ||
| 2861 | */ | ||
| 2862 | 482 | Query_log_event end_evt(thd, query.data(), query.length(), true, false, | |
| 2863 |
1/2✓ Branch 0 taken 482 times.
✗ Branch 1 not taken.
|
964 | true, 0, true); |
| 2864 | 964 | error = thd->lex->sql_command != SQLCOM_XA_ROLLBACK | |
| 2865 |
2/4✓ Branch 0 taken 482 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 482 times.
✗ Branch 3 not taken.
|
482 | ? cache_mngr->trx_cache.finalize(thd, &end_evt) |
| 2866 | ✗ | : cache_mngr->trx_cache.finalize(thd, &end_evt, xs); | |
| 2867 | 482 | stuff_logged = true; | |
| 2868 | 482 | } else { | |
| 2869 | /* | ||
| 2870 | If the transaction is being rolled back and its changes can be | ||
| 2871 | rolled back, the trx-cache's content is truncated. | ||
| 2872 | */ | ||
| 2873 |
1/2✓ Branch 0 taken 4696 times.
✗ Branch 1 not taken.
|
4696 | error = cache_mngr->trx_cache.truncate(thd, all); |
| 2874 | |||
| 2875 |
4/6✓ Branch 0 taken 4697 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 4695 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
4696 | DBUG_EXECUTE_IF("ensure_binlog_cache_is_reset", { |
| 2876 | /* Assert that binlog cache is reset at rollback time. */ | ||
| 2877 | assert(binlog_cache_is_reset); | ||
| 2878 | binlog_cache_is_reset = false; | ||
| 2879 | };); | ||
| 2880 | } | ||
| 2881 | } else { | ||
| 2882 | /* | ||
| 2883 | If a statement is being rolled back, it is necessary to know | ||
| 2884 | exactly why a statement may not be safely rolled back as in | ||
| 2885 | some specific situations the trx-cache can be truncated. | ||
| 2886 | |||
| 2887 | If a temporary table is created or dropped, the trx-cache is not | ||
| 2888 | truncated. Note that if the stmt-cache is used, there is nothing | ||
| 2889 | to truncate in the trx-cache. | ||
| 2890 | |||
| 2891 | If a non-transactional table is updated and the binlog format is | ||
| 2892 | statement, the trx-cache is not truncated. The trx-cache is used | ||
| 2893 | when the direct option is off and a transactional table has been | ||
| 2894 | updated before the current statement in the context of the | ||
| 2895 | current transaction. Note that if the stmt-cache is used there is | ||
| 2896 | nothing to truncate in the trx-cache. | ||
| 2897 | |||
| 2898 | If other binlog formats are used, updates to non-transactional | ||
| 2899 | tables are written to the stmt-cache and trx-cache can be safely | ||
| 2900 | truncated, if necessary. | ||
| 2901 | */ | ||
| 2902 |
1/2✓ Branch 0 taken 4433 times.
✗ Branch 1 not taken.
|
8869 | if (thd->get_transaction()->has_dropped_temp_table(Transaction_ctx::STMT) || |
| 2903 |
5/6✓ Branch 0 taken 4435 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 630 times.
✓ Branch 3 taken 3807 times.
✓ Branch 4 taken 293 times.
✓ Branch 5 taken 4143 times.
|
9501 | thd->get_transaction()->has_created_temp_table(Transaction_ctx::STMT) || |
| 2904 | 4433 | (thd->get_transaction()->has_modified_non_trans_table( | |
| 2905 | 630 | Transaction_ctx::STMT) && | |
| 2906 |
2/2✓ Branch 0 taken 294 times.
✓ Branch 1 taken 336 times.
|
630 | thd->variables.binlog_format == BINLOG_FORMAT_STMT)) { |
| 2907 | /* | ||
| 2908 | If the statement is being rolled back and dropped or created a | ||
| 2909 | temporary table or modified a non-transactional table and the | ||
| 2910 | statement-based replication is in use, the statement's changes | ||
| 2911 | in the trx-cache are preserved. | ||
| 2912 | */ | ||
| 2913 |
1/2✓ Branch 0 taken 293 times.
✗ Branch 1 not taken.
|
293 | cache_mngr->trx_cache.set_prev_position(MY_OFF_T_UNDEF); |
| 2914 | } else { | ||
| 2915 | /* | ||
| 2916 | Otherwise, the statement's changes in the trx-cache are | ||
| 2917 | truncated. | ||
| 2918 | */ | ||
| 2919 |
1/2✓ Branch 0 taken 4146 times.
✗ Branch 1 not taken.
|
4143 | error = cache_mngr->trx_cache.truncate(thd, all); |
| 2920 | } | ||
| 2921 | } | ||
| 2922 |
2/2✓ Branch 0 taken 1286 times.
✓ Branch 1 taken 8332 times.
|
9618 | if (stuff_logged) { |
| 2923 | 1286 | Transaction_ctx *trn_ctx = thd->get_transaction(); | |
| 2924 |
1/2✓ Branch 0 taken 1286 times.
✗ Branch 1 not taken.
|
1286 | trn_ctx->store_commit_parent( |
| 2925 | m_dependency_tracker.get_max_committed_timestamp()); | ||
| 2926 | } | ||
| 2927 | |||
| 2928 |
3/8✓ Branch 0 taken 9609 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9618 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9618 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
9618 | DBUG_PRINT("debug", ("error: %d", error)); |
| 2929 |
4/4✓ Branch 0 taken 9617 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1286 times.
✓ Branch 3 taken 8331 times.
|
9618 | if (error == 0 && stuff_logged) { |
| 2930 |
2/4✓ Branch 0 taken 1286 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1286 times.
✗ Branch 3 not taken.
|
1286 | CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_invoke_before_commit_hook"); |
| 2931 |
7/12✓ Branch 0 taken 1286 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1268 times.
✓ Branch 3 taken 18 times.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 18 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 18 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 1286 times.
|
1286 | if (RUN_HOOK( |
| 2932 | transaction, before_commit, | ||
| 2933 | (thd, all, thd_get_cache_mngr(thd)->get_trx_cache(), | ||
| 2934 | thd_get_cache_mngr(thd)->get_stmt_cache(), | ||
| 2935 | max<my_off_t>(max_binlog_cache_size, max_binlog_stmt_cache_size), | ||
| 2936 | false))) { | ||
| 2937 | // Reset the thread OK status before changing the outcome. | ||
| 2938 | ✗ | if (thd->get_stmt_da()->is_ok()) | |
| 2939 | ✗ | thd->get_stmt_da()->reset_diagnostics_area(); | |
| 2940 | ✗ | my_error(ER_RUN_HOOK_ERROR, MYF(0), "before_commit"); | |
| 2941 | ✗ | return RESULT_ABORTED; | |
| 2942 | } | ||
| 2943 | // XA rollback is always accepted. | ||
| 2944 |
2/4✓ Branch 0 taken 1286 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1286 times.
|
1286 | assert(!thd->get_transaction() |
| 2945 | ->get_rpl_transaction_ctx() | ||
| 2946 | ->is_transaction_rollback()); | ||
| 2947 | |||
| 2948 |
1/2✓ Branch 0 taken 1283 times.
✗ Branch 1 not taken.
|
1286 | error = ordered_commit(thd, all, /* skip_commit */ true); |
| 2949 | |||
| 2950 | // Inform hook listeners that a XA ROLLBACK did commit, that | ||
| 2951 | // is, did log a transaction to the binary log. | ||
| 2952 |
6/8✓ Branch 0 taken 1283 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1283 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 143 times.
✓ Branch 5 taken 1140 times.
✓ Branch 6 taken 143 times.
✓ Branch 7 taken 1140 times.
|
1283 | if (!error && is_xa_rollback(thd)) |
| 2953 |
4/6✓ Branch 0 taken 143 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 126 times.
✓ Branch 4 taken 17 times.
✗ Branch 5 not taken.
|
143 | (void)RUN_HOOK(transaction, after_commit, (thd, all)); |
| 2954 | } | ||
| 2955 | |||
| 2956 | #ifdef WITH_WSREP | ||
| 2957 |
13/16✓ Branch 0 taken 9608 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 673 times.
✓ Branch 3 taken 8935 times.
✓ Branch 4 taken 673 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 673 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 648 times.
✓ Branch 9 taken 25 times.
✓ Branch 10 taken 9588 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 107 times.
✓ Branch 13 taken 9481 times.
✓ Branch 14 taken 9506 times.
✓ Branch 15 taken 107 times.
|
9615 | if (!WSREP_EMULATE_BINLOG(thd) && check_write_error(thd)) { |
| 2958 | #else | ||
| 2959 | if (check_write_error(thd)) { | ||
| 2960 | #endif /* WITH_WSREP */ | ||
| 2961 | /* | ||
| 2962 | We reach this point if the effect of a statement did not properly get into | ||
| 2963 | a cache and need to be rolled back. | ||
| 2964 | */ | ||
| 2965 |
1/2✓ Branch 0 taken 107 times.
✗ Branch 1 not taken.
|
107 | error |= cache_mngr->trx_cache.truncate(thd, all); |
| 2966 | } | ||
| 2967 | |||
| 2968 | 9506 | end: | |
| 2969 | // The caches may be empty if an `XA ROLLBACK` was issued just after `XA | ||
| 2970 | // END`. In that case, the BCG will not be invoked and we need to | ||
| 2971 | // rollback in SEs and finalize GTID state. | ||
| 2972 |
9/10✓ Branch 0 taken 1838273 times.
✓ Branch 1 taken 277 times.
✓ Branch 2 taken 1837041 times.
✓ Branch 3 taken 1232 times.
✓ Branch 4 taken 1837202 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 93 times.
✓ Branch 7 taken 1837109 times.
✓ Branch 8 taken 93 times.
✓ Branch 9 taken 1838618 times.
|
1838550 | if (!error && !stuff_logged && is_xa_rollback(thd)) { |
| 2973 |
1/2✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
|
93 | error = trx_coordinator::rollback_in_engines(thd, all); |
| 2974 |
6/8✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 93 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 66 times.
✓ Branch 5 taken 27 times.
✓ Branch 6 taken 66 times.
✓ Branch 7 taken 27 times.
|
93 | if (!error && !thd->is_error()) { |
| 2975 | /* | ||
| 2976 | XA-rollback ignores the gtid_state, if the transaciton | ||
| 2977 | is empty. | ||
| 2978 | */ | ||
| 2979 |
4/6✓ Branch 0 taken 66 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 60 times.
✗ Branch 5 not taken.
|
66 | if (is_empty && !thd->slave_thread) gtid_state->update_on_rollback(thd); |
| 2980 | /* | ||
| 2981 | XA-rollback commits the new gtid_state, if transaction | ||
| 2982 | is not empty. | ||
| 2983 | */ | ||
| 2984 | else { | ||
| 2985 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | gtid_state->update_on_commit(thd); |
| 2986 | /* | ||
| 2987 | Inform hook listeners that a XA ROLLBACK did commit, that | ||
| 2988 | is, did log a transaction to the binary log. | ||
| 2989 | */ | ||
| 2990 |
2/6✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
6 | (void)RUN_HOOK(transaction, after_commit, (thd, all)); |
| 2991 | } | ||
| 2992 | } | ||
| 2993 | } | ||
| 2994 | /* | ||
| 2995 | When a statement errors out on auto-commit mode it is rollback | ||
| 2996 | implicitly, so the same should happen to its GTID. | ||
| 2997 | */ | ||
| 2998 |
2/2✓ Branch 0 taken 1826805 times.
✓ Branch 1 taken 11842 times.
|
1838711 | if (!thd->in_active_multi_stmt_transaction()) |
| 2999 |
1/2✓ Branch 0 taken 1828152 times.
✗ Branch 1 not taken.
|
1826805 | gtid_state->update_on_rollback(thd); |
| 3000 | |||
| 3001 | /* | ||
| 3002 | TODO: some errors are overwritten, which may cause problem, | ||
| 3003 | fix it later. | ||
| 3004 | */ | ||
| 3005 |
5/8✓ Branch 0 taken 1839590 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1839287 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 1839281 times.
✓ Branch 6 taken 8 times.
✗ Branch 7 not taken.
|
1839994 | DBUG_PRINT("return", ("error: %d", error)); |
| 3006 | 1839289 | return error; | |
| 3007 | 1839289 | } | |
| 3008 | |||
| 3009 | /** | ||
| 3010 | @note | ||
| 3011 | How do we handle this (unlikely but legal) case: | ||
| 3012 | @verbatim | ||
| 3013 | [transaction] + [update to non-trans table] + [rollback to savepoint] ? | ||
| 3014 | @endverbatim | ||
| 3015 | The problem occurs when a savepoint is before the update to the | ||
| 3016 | non-transactional table. Then when there's a rollback to the savepoint, if we | ||
| 3017 | simply truncate the binlog cache, we lose the part of the binlog cache where | ||
| 3018 | the update is. If we want to not lose it, we need to write the SAVEPOINT | ||
| 3019 | command and the ROLLBACK TO SAVEPOINT command to the binlog cache. The latter | ||
| 3020 | is easy: it's just write at the end of the binlog cache, but the former | ||
| 3021 | should be *inserted* to the place where the user called SAVEPOINT. The | ||
| 3022 | solution is that when the user calls SAVEPOINT, we write it to the binlog | ||
| 3023 | cache (so no need to later insert it). As transactions are never intermixed | ||
| 3024 | in the binary log (i.e. they are serialized), we won't have conflicts with | ||
| 3025 | savepoint names when using mysqlbinlog or in the slave SQL thread. | ||
| 3026 | Then when ROLLBACK TO SAVEPOINT is called, if we updated some | ||
| 3027 | non-transactional table, we don't truncate the binlog cache but instead write | ||
| 3028 | ROLLBACK TO SAVEPOINT to it; otherwise we truncate the binlog cache (which | ||
| 3029 | will chop the SAVEPOINT command from the binlog cache, which is good as in | ||
| 3030 | that case there is no need to have it in the binlog). | ||
| 3031 | */ | ||
| 3032 | |||
| 3033 | 7894 | static int binlog_savepoint_set(handlerton *, THD *thd, void *sv) { | |
| 3034 |
1/2✓ Branch 0 taken 7895 times.
✗ Branch 1 not taken.
|
7894 | DBUG_TRACE; |
| 3035 | 7895 | int error = 1; | |
| 3036 | |||
| 3037 | #ifdef WITH_WSREP | ||
| 3038 | /* | ||
| 3039 | Clear table maps before writing SAVEPOINT event. This enforces | ||
| 3040 | recreation of table map events for the following row event. | ||
| 3041 | */ | ||
| 3042 | 7895 | thd->clear_binlog_table_maps(); | |
| 3043 | #endif /* WITH_WSREP */ | ||
| 3044 | |||
| 3045 | 7894 | String log_query; | |
| 3046 |
2/4✓ Branch 0 taken 7894 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7894 times.
|
7894 | if (log_query.append(STRING_WITH_LEN("SAVEPOINT "))) |
| 3047 | ✗ | return error; | |
| 3048 | else | ||
| 3049 | 7894 | append_identifier(thd, &log_query, thd->lex->ident.str, | |
| 3050 |
1/2✓ Branch 0 taken 7895 times.
✗ Branch 1 not taken.
|
7894 | thd->lex->ident.length); |
| 3051 | |||
| 3052 |
1/2✓ Branch 0 taken 7895 times.
✗ Branch 1 not taken.
|
7895 | int errcode = query_error_code(thd, thd->killed == THD::NOT_KILLED); |
| 3053 |
1/2✓ Branch 0 taken 7895 times.
✗ Branch 1 not taken.
|
7895 | Query_log_event qinfo(thd, log_query.c_ptr_safe(), log_query.length(), true, |
| 3054 |
1/2✓ Branch 0 taken 7895 times.
✗ Branch 1 not taken.
|
15790 | false, true, errcode); |
| 3055 | /* | ||
| 3056 | We cannot record the position before writing the statement | ||
| 3057 | because a rollback to a savepoint (.e.g. consider it "S") would | ||
| 3058 | prevent the savepoint statement (i.e. "SAVEPOINT S") from being | ||
| 3059 | written to the binary log despite the fact that the server could | ||
| 3060 | still issue other rollback statements to the same savepoint (i.e. | ||
| 3061 | "S"). | ||
| 3062 | Given that the savepoint is valid until the server releases it, | ||
| 3063 | ie, until the transaction commits or it is released explicitly, | ||
| 3064 | we need to log it anyway so that we don't have "ROLLBACK TO S" | ||
| 3065 | or "RELEASE S" without the preceding "SAVEPOINT S" in the binary | ||
| 3066 | log. | ||
| 3067 | */ | ||
| 3068 |
2/4✓ Branch 0 taken 7894 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7894 times.
✗ Branch 3 not taken.
|
7895 | if (!(error = mysql_bin_log.write_event(&qinfo))) |
| 3069 |
1/2✓ Branch 0 taken 7895 times.
✗ Branch 1 not taken.
|
7894 | binlog_trans_log_savepos(thd, (my_off_t *)sv); |
| 3070 | |||
| 3071 | 7895 | return error; | |
| 3072 | 7895 | } | |
| 3073 | |||
| 3074 | 4053 | static int binlog_savepoint_rollback(handlerton *, THD *thd, void *sv) { | |
| 3075 |
1/2✓ Branch 0 taken 4053 times.
✗ Branch 1 not taken.
|
4053 | DBUG_TRACE; |
| 3076 |
1/2✓ Branch 0 taken 4053 times.
✗ Branch 1 not taken.
|
4053 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); |
| 3077 | 4053 | my_off_t pos = *(my_off_t *)sv; | |
| 3078 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4053 times.
|
4053 | assert(pos != ~(my_off_t)0); |
| 3079 | |||
| 3080 | /* | ||
| 3081 | Write ROLLBACK TO SAVEPOINT to the binlog cache if we have updated some | ||
| 3082 | non-transactional table. Otherwise, truncate the binlog cache starting | ||
| 3083 | from the SAVEPOINT command. | ||
| 3084 | */ | ||
| 3085 | #ifdef WITH_WSREP | ||
| 3086 | /* | ||
| 3087 | For streaming replication, we must replicate savepoint rollback so that | ||
| 3088 | slaves can maintain SR transactions | ||
| 3089 | */ | ||
| 3090 |
7/8✓ Branch 0 taken 4050 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 4050 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 15 times.
✓ Branch 5 taken 4035 times.
✓ Branch 6 taken 18 times.
✓ Branch 7 taken 4035 times.
|
4053 | if (thd->wsrep_trx().is_streaming() || trans_cannot_safely_rollback(thd)) { |
| 3091 | #else | ||
| 3092 | if (trans_cannot_safely_rollback(thd)) { | ||
| 3093 | #endif /* WITH_WSREP */ | ||
| 3094 | 18 | String log_query; | |
| 3095 |
2/4✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 18 times.
|
18 | if (log_query.append(STRING_WITH_LEN("ROLLBACK TO "))) |
| 3096 | ✗ | return 1; | |
| 3097 | else { | ||
| 3098 | /* | ||
| 3099 | Before writing identifier to the binlog, make sure to | ||
| 3100 | quote the identifier properly so as to prevent any SQL | ||
| 3101 | injection on the slave. | ||
| 3102 | */ | ||
| 3103 | 18 | append_identifier(thd, &log_query, thd->lex->ident.str, | |
| 3104 |
1/2✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
|
18 | thd->lex->ident.length); |
| 3105 | } | ||
| 3106 | |||
| 3107 |
1/2✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
|
18 | int errcode = query_error_code(thd, thd->killed == THD::NOT_KILLED); |
| 3108 |
1/2✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
|
18 | Query_log_event qinfo(thd, log_query.c_ptr_safe(), log_query.length(), true, |
| 3109 |
1/2✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
|
36 | false, true, errcode); |
| 3110 |
1/2✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
|
18 | return mysql_bin_log.write_event(&qinfo); |
| 3111 | 18 | } | |
| 3112 | // Otherwise, we truncate the cache | ||
| 3113 |
1/2✓ Branch 0 taken 4035 times.
✗ Branch 1 not taken.
|
4035 | cache_mngr->trx_cache.restore_savepoint(pos); |
| 3114 | /* | ||
| 3115 | When a SAVEPOINT is executed inside a stored function/trigger we force the | ||
| 3116 | pending event to be flushed with a STMT_END_F flag and clear the table maps | ||
| 3117 | as well to ensure that following DMLs will have a clean state to start | ||
| 3118 | with. ROLLBACK inside a stored routine has to finalize possibly existing | ||
| 3119 | current row-based pending event with cleaning up table maps. That ensures | ||
| 3120 | that following DMLs will have a clean state to start with. | ||
| 3121 | */ | ||
| 3122 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 4019 times.
|
4035 | if (thd->in_sub_stmt) thd->clear_binlog_table_maps(); |
| 3123 | 4035 | return 0; | |
| 3124 | 4053 | } | |
| 3125 | |||
| 3126 | /** | ||
| 3127 | purge logs, master and slave sides both, related error code | ||
| 3128 | converter. | ||
| 3129 | Called from @c purge_error_message(), @c MYSQL_BIN_LOG::reset_logs() | ||
| 3130 | |||
| 3131 | @param res an error code as used by purging routines | ||
| 3132 | |||
| 3133 | @return the user level error code ER_* | ||
| 3134 | */ | ||
| 3135 | 146 | static uint purge_log_get_error_code(int res) { | |
| 3136 | 146 | uint errcode = 0; | |
| 3137 | |||
| 3138 |
2/11✓ Branch 0 taken 135 times.
✓ Branch 1 taken 11 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
|
146 | switch (res) { |
| 3139 | 135 | case 0: | |
| 3140 | 135 | break; | |
| 3141 | 11 | case LOG_INFO_EOF: | |
| 3142 | 11 | errcode = ER_UNKNOWN_TARGET_BINLOG; | |
| 3143 | 11 | break; | |
| 3144 | ✗ | case LOG_INFO_IO: | |
| 3145 | ✗ | errcode = ER_IO_ERR_LOG_INDEX_READ; | |
| 3146 | ✗ | break; | |
| 3147 | ✗ | case LOG_INFO_INVALID: | |
| 3148 | ✗ | errcode = ER_BINLOG_PURGE_PROHIBITED; | |
| 3149 | ✗ | break; | |
| 3150 | ✗ | case LOG_INFO_SEEK: | |
| 3151 | ✗ | errcode = ER_FSEEK_FAIL; | |
| 3152 | ✗ | break; | |
| 3153 | ✗ | case LOG_INFO_MEM: | |
| 3154 | ✗ | errcode = ER_OUT_OF_RESOURCES; | |
| 3155 | ✗ | break; | |
| 3156 | ✗ | case LOG_INFO_FATAL: | |
| 3157 | ✗ | errcode = ER_BINLOG_PURGE_FATAL_ERR; | |
| 3158 | ✗ | break; | |
| 3159 | ✗ | case LOG_INFO_IN_USE: | |
| 3160 | ✗ | errcode = ER_LOG_IN_USE; | |
| 3161 | ✗ | break; | |
| 3162 | ✗ | case LOG_INFO_EMFILE: | |
| 3163 | ✗ | errcode = ER_BINLOG_PURGE_EMFILE; | |
| 3164 | ✗ | break; | |
| 3165 | ✗ | case LOG_INFO_BACKUP_LOCK: | |
| 3166 | ✗ | errcode = ER_CANNOT_PURGE_BINLOG_WITH_BACKUP_LOCK; | |
| 3167 | ✗ | break; | |
| 3168 | ✗ | default: | |
| 3169 | ✗ | errcode = ER_LOG_PURGE_UNKNOWN_ERR; | |
| 3170 | ✗ | break; | |
| 3171 | } | ||
| 3172 | |||
| 3173 | 146 | return errcode; | |
| 3174 | } | ||
| 3175 | |||
| 3176 | /** | ||
| 3177 | Check whether binlog state allows to safely release MDL locks after | ||
| 3178 | rollback to savepoint. | ||
| 3179 | |||
| 3180 | @param thd The client thread that executes the transaction. | ||
| 3181 | |||
| 3182 | @return true - It is safe to release MDL locks. | ||
| 3183 | false - If it is not. | ||
| 3184 | */ | ||
| 3185 | 4046 | static bool binlog_savepoint_rollback_can_release_mdl(handlerton *, THD *thd) { | |
| 3186 |
1/2✓ Branch 0 taken 4046 times.
✗ Branch 1 not taken.
|
4046 | DBUG_TRACE; |
| 3187 | /** | ||
| 3188 | If we have not updated any non-transactional tables rollback | ||
| 3189 | to savepoint will simply truncate binlog cache starting from | ||
| 3190 | SAVEPOINT command. So it should be safe to release MDL acquired | ||
| 3191 | after SAVEPOINT command in this case. | ||
| 3192 | */ | ||
| 3193 |
1/2✓ Branch 0 taken 4046 times.
✗ Branch 1 not taken.
|
8092 | return !trans_cannot_safely_rollback(thd); |
| 3194 | 4046 | } | |
| 3195 | |||
| 3196 | /** | ||
| 3197 | Adjust log offset in the binary log file for all running slaves | ||
| 3198 | This class implements call back function for do_for_all_thd(). | ||
| 3199 | It is called for each thd in thd list to adjust offset. | ||
| 3200 | */ | ||
| 3201 | class Adjust_offset : public Do_THD_Impl { | ||
| 3202 | public: | ||
| 3203 | 207 | Adjust_offset(my_off_t value) : m_purge_offset(value) {} | |
| 3204 | 866 | void operator()(THD *thd) override { | |
| 3205 | LOG_INFO *linfo; | ||
| 3206 | 866 | mysql_mutex_lock(&thd->LOCK_thd_data); | |
| 3207 |
2/2✓ Branch 0 taken 83 times.
✓ Branch 1 taken 783 times.
|
866 | if ((linfo = thd->current_linfo)) { |
| 3208 | /* | ||
| 3209 | Index file offset can be less that purge offset only if | ||
| 3210 | we just started reading the index file. In that case | ||
| 3211 | we have nothing to adjust. | ||
| 3212 | */ | ||
| 3213 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 81 times.
|
83 | if (linfo->index_file_offset < m_purge_offset) |
| 3214 | 2 | linfo->fatal = (linfo->index_file_offset != 0); | |
| 3215 | else | ||
| 3216 | 81 | linfo->index_file_offset -= m_purge_offset; | |
| 3217 | } | ||
| 3218 | 866 | mysql_mutex_unlock(&thd->LOCK_thd_data); | |
| 3219 | 866 | } | |
| 3220 | |||
| 3221 | private: | ||
| 3222 | my_off_t m_purge_offset; | ||
| 3223 | }; | ||
| 3224 | |||
| 3225 | /* | ||
| 3226 | Adjust the position pointer in the binary log file for all running slaves. | ||
| 3227 | |||
| 3228 | SYNOPSIS | ||
| 3229 | adjust_linfo_offsets() | ||
| 3230 | purge_offset Number of bytes removed from start of log index file | ||
| 3231 | |||
| 3232 | NOTES | ||
| 3233 | - This is called when doing a PURGE when we delete lines from the | ||
| 3234 | index log file. | ||
| 3235 | |||
| 3236 | REQUIREMENTS | ||
| 3237 | - Before calling this function, we have to ensure that no threads are | ||
| 3238 | using any binary log file before purge_offset. | ||
| 3239 | |||
| 3240 | TODO | ||
| 3241 | - Inform the slave threads that they should sync the position | ||
| 3242 | in the binary log file with flush_relay_log_info. | ||
| 3243 | Now they sync is done for next read. | ||
| 3244 | */ | ||
| 3245 | 207 | static void adjust_linfo_offsets(my_off_t purge_offset) { | |
| 3246 |
1/2✓ Branch 0 taken 207 times.
✗ Branch 1 not taken.
|
207 | Adjust_offset adjust_offset(purge_offset); |
| 3247 |
1/2✓ Branch 0 taken 207 times.
✗ Branch 1 not taken.
|
207 | Global_THD_manager::get_instance()->do_for_all_thd(&adjust_offset); |
| 3248 | 207 | } | |
| 3249 | |||
| 3250 | /** | ||
| 3251 | This class implements Call back function for do_for_all_thd(). | ||
| 3252 | It is called for each thd in thd list to count | ||
| 3253 | threads using bin log file | ||
| 3254 | */ | ||
| 3255 | |||
| 3256 | class Log_in_use : public Do_THD_Impl { | ||
| 3257 | public: | ||
| 3258 | 15204 | Log_in_use(const char *value) : m_log_name(value), m_count(0) { | |
| 3259 | 15204 | m_log_name_len = strlen(m_log_name) + 1; | |
| 3260 | 15204 | } | |
| 3261 | 164756 | void operator()(THD *thd) override { | |
| 3262 | LOG_INFO *linfo; | ||
| 3263 | 164756 | mysql_mutex_lock(&thd->LOCK_thd_data); | |
| 3264 |
2/2✓ Branch 0 taken 237 times.
✓ Branch 1 taken 164519 times.
|
164756 | if ((linfo = thd->current_linfo)) { |
| 3265 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 237 times.
|
237 | if (!strncmp(m_log_name, linfo->log_file_name, m_log_name_len)) { |
| 3266 | ✗ | LogErr(WARNING_LEVEL, ER_BINLOG_FILE_BEING_READ_NOT_PURGED, m_log_name, | |
| 3267 | thd->thread_id()); | ||
| 3268 | ✗ | m_count++; | |
| 3269 | } | ||
| 3270 | } | ||
| 3271 | 164756 | mysql_mutex_unlock(&thd->LOCK_thd_data); | |
| 3272 | 164756 | } | |
| 3273 | 15204 | int get_count() { return m_count; } | |
| 3274 | |||
| 3275 | private: | ||
| 3276 | const char *m_log_name; | ||
| 3277 | size_t m_log_name_len; | ||
| 3278 | int m_count; | ||
| 3279 | }; | ||
| 3280 | |||
| 3281 | 15204 | static int log_in_use(const char *log_name) { | |
| 3282 |
1/2✓ Branch 0 taken 15204 times.
✗ Branch 1 not taken.
|
15204 | Log_in_use log_in_use(log_name); |
| 3283 | #ifndef NDEBUG | ||
| 3284 |
3/4✓ Branch 0 taken 15204 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14974 times.
✓ Branch 3 taken 230 times.
|
15204 | if (current_thd) |
| 3285 |
3/6✓ Branch 0 taken 14974 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14974 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14974 times.
✗ Branch 5 not taken.
|
14974 | DEBUG_SYNC(current_thd, "purge_logs_after_lock_index_before_thread_count"); |
| 3286 | #endif | ||
| 3287 |
1/2✓ Branch 0 taken 15204 times.
✗ Branch 1 not taken.
|
15204 | Global_THD_manager::get_instance()->do_for_all_thd(&log_in_use); |
| 3288 | 30408 | return log_in_use.get_count(); | |
| 3289 | 15204 | } | |
| 3290 | |||
| 3291 | 137 | static bool purge_error_message(THD *thd, int res) { | |
| 3292 | uint errcode; | ||
| 3293 | |||
| 3294 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 135 times.
|
137 | if ((errcode = purge_log_get_error_code(res)) != 0) { |
| 3295 | 2 | my_error(errcode, MYF(0)); | |
| 3296 | 2 | return true; | |
| 3297 | } | ||
| 3298 | 135 | my_ok(thd); | |
| 3299 | 135 | return false; | |
| 3300 | } | ||
| 3301 | |||
| 3302 | 278 | bool is_transaction_empty(THD *thd) { | |
| 3303 |
1/2✓ Branch 0 taken 278 times.
✗ Branch 1 not taken.
|
278 | DBUG_TRACE; |
| 3304 |
1/2✓ Branch 0 taken 278 times.
✗ Branch 1 not taken.
|
278 | int rw_ha_count = check_trx_rw_engines(thd, Transaction_ctx::SESSION); |
| 3305 |
1/2✓ Branch 0 taken 278 times.
✗ Branch 1 not taken.
|
278 | rw_ha_count += check_trx_rw_engines(thd, Transaction_ctx::STMT); |
| 3306 | 278 | return rw_ha_count == 0; | |
| 3307 | 278 | } | |
| 3308 | |||
| 3309 | 556 | int check_trx_rw_engines(THD *thd, Transaction_ctx::enum_trx_scope trx_scope) { | |
| 3310 |
1/2✓ Branch 0 taken 556 times.
✗ Branch 1 not taken.
|
556 | DBUG_TRACE; |
| 3311 | |||
| 3312 | 556 | int rw_ha_count = 0; | |
| 3313 |
1/2✓ Branch 0 taken 556 times.
✗ Branch 1 not taken.
|
556 | auto ha_list = thd->get_transaction()->ha_trx_info(trx_scope); |
| 3314 | |||
| 3315 |
7/12✓ Branch 0 taken 556 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 556 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 477 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 477 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1033 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 477 times.
✓ Branch 11 taken 556 times.
|
1033 | for (auto const &ha_info : ha_list) { |
| 3316 |
2/4✓ Branch 0 taken 477 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 477 times.
✗ Branch 3 not taken.
|
477 | if (ha_info.is_trx_read_write()) ++rw_ha_count; |
| 3317 | 556 | } | |
| 3318 | 556 | return rw_ha_count; | |
| 3319 | 556 | } | |
| 3320 | |||
| 3321 | 884 | bool is_empty_transaction_in_binlog_cache(const THD *thd) { | |
| 3322 |
1/2✓ Branch 0 taken 884 times.
✗ Branch 1 not taken.
|
884 | DBUG_TRACE; |
| 3323 | |||
| 3324 |
1/2✓ Branch 0 taken 884 times.
✗ Branch 1 not taken.
|
884 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); |
| 3325 |
6/8✓ Branch 0 taken 884 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 884 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10 times.
✓ Branch 5 taken 874 times.
✓ Branch 6 taken 10 times.
✓ Branch 7 taken 874 times.
|
884 | if (cache_mngr != nullptr && cache_mngr->has_empty_transaction()) { |
| 3326 | 10 | return true; | |
| 3327 | } | ||
| 3328 | |||
| 3329 | 874 | return false; | |
| 3330 | 884 | } | |
| 3331 | |||
| 3332 | /** | ||
| 3333 | This function checks if a transactional table was updated by the | ||
| 3334 | current transaction. | ||
| 3335 | |||
| 3336 | @param thd The client thread that executed the current statement. | ||
| 3337 | @return | ||
| 3338 | @c true if a transactional table was updated, @c false otherwise. | ||
| 3339 | */ | ||
| 3340 | 24035911 | bool trans_has_updated_trans_table(const THD *thd) { | |
| 3341 | 24035911 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); | |
| 3342 | |||
| 3343 |
2/2✓ Branch 0 taken 16678801 times.
✓ Branch 1 taken 7358870 times.
|
24037671 | return (cache_mngr ? !cache_mngr->trx_cache.is_binlog_empty() : 0); |
| 3344 | } | ||
| 3345 | |||
| 3346 | /** | ||
| 3347 | This function checks if a transactional table was updated by the | ||
| 3348 | current statement. | ||
| 3349 | |||
| 3350 | @param ha_list Registered storage engine handler list. | ||
| 3351 | @return | ||
| 3352 | @c true if a transactional table was updated, @c false otherwise. | ||
| 3353 | */ | ||
| 3354 | 3545152 | bool stmt_has_updated_trans_table(Ha_trx_info_list const &ha_list) { | |
| 3355 |
7/12✓ Branch 0 taken 3545287 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3545257 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5509816 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2390800 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 5935979 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 5509807 times.
✓ Branch 11 taken 426172 times.
|
5935954 | for (auto const &ha_info : ha_list) { |
| 3356 |
7/8✓ Branch 0 taken 5509819 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5505993 times.
✓ Branch 3 taken 3826 times.
✓ Branch 4 taken 3119019 times.
✓ Branch 5 taken 2386976 times.
✓ Branch 6 taken 3119019 times.
✓ Branch 7 taken 2390802 times.
|
5509816 | if (ha_info.is_trx_read_write() && ha_info.ht() != binlog_hton) |
| 3357 | 3119019 | return (true); | |
| 3358 |
4/4✓ Branch 0 taken 426176 times.
✓ Branch 1 taken 3119009 times.
✓ Branch 2 taken 426372 times.
✓ Branch 3 taken 3119016 times.
|
6664200 | } |
| 3359 | 426372 | return (false); | |
| 3360 | } | ||
| 3361 | |||
| 3362 | /** | ||
| 3363 | This function checks if a transaction, either a multi-statement | ||
| 3364 | or a single statement transaction is about to commit or not. | ||
| 3365 | |||
| 3366 | @param thd The client thread that executed the current statement. | ||
| 3367 | @param all Committing a transaction (i.e. true) or a statement | ||
| 3368 | (i.e. false). | ||
| 3369 | @return | ||
| 3370 | @c true if committing a transaction, otherwise @c false. | ||
| 3371 | */ | ||
| 3372 | 18275746 | bool ending_trans(THD *thd, const bool all) { | |
| 3373 |
4/4✓ Branch 0 taken 14816396 times.
✓ Branch 1 taken 3459350 times.
✓ Branch 2 taken 3567803 times.
✓ Branch 3 taken 11248613 times.
|
18275746 | return (all || ending_single_stmt_trans(thd, all)); |
| 3374 | } | ||
| 3375 | |||
| 3376 | /** | ||
| 3377 | This function checks if a single statement transaction is about | ||
| 3378 | to commit or not. | ||
| 3379 | |||
| 3380 | @param thd The client thread that executed the current statement. | ||
| 3381 | @param all Committing a transaction (i.e. true) or a statement | ||
| 3382 | (i.e. false). | ||
| 3383 | @return | ||
| 3384 | @c true if committing a single statement transaction, otherwise | ||
| 3385 | @c false. | ||
| 3386 | */ | ||
| 3387 | 14816323 | bool ending_single_stmt_trans(THD *thd, const bool all) { | |
| 3388 |
3/4✓ Branch 0 taken 14816343 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3567752 times.
✓ Branch 3 taken 11248637 times.
|
14816323 | return (!all && !thd->in_multi_stmt_transaction_mode()); |
| 3389 | } | ||
| 3390 | |||
| 3391 | /** | ||
| 3392 | This function checks if a transaction cannot be rolled back safely. | ||
| 3393 | |||
| 3394 | @param thd The client thread that executed the current statement. | ||
| 3395 | @return | ||
| 3396 | @c true if cannot be safely rolled back, @c false otherwise. | ||
| 3397 | */ | ||
| 3398 | 13274 | bool trans_cannot_safely_rollback(const THD *thd) { | |
| 3399 | 13274 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); | |
| 3400 | |||
| 3401 | 13275 | return cache_mngr->trx_cache.cannot_rollback(); | |
| 3402 | } | ||
| 3403 | |||
| 3404 | /** | ||
| 3405 | This function checks if current statement cannot be rollded back safely. | ||
| 3406 | |||
| 3407 | @param thd The client thread that executed the current statement. | ||
| 3408 | @return | ||
| 3409 | @c true if cannot be safely rolled back, @c false otherwise. | ||
| 3410 | */ | ||
| 3411 | 583665 | bool stmt_cannot_safely_rollback(const THD *thd) { | |
| 3412 | 583665 | return thd->get_transaction()->cannot_safely_rollback(Transaction_ctx::STMT); | |
| 3413 | } | ||
| 3414 | |||
| 3415 | /** | ||
| 3416 | Execute a PURGE BINARY LOGS TO @<log@> command. | ||
| 3417 | |||
| 3418 | @param thd Pointer to THD object for the client thread executing the | ||
| 3419 | statement. | ||
| 3420 | |||
| 3421 | @param to_log Name of the last log to purge. | ||
| 3422 | |||
| 3423 | @retval false success | ||
| 3424 | @retval true failure | ||
| 3425 | */ | ||
| 3426 | 111 | bool purge_source_logs_to_file(THD *thd, const char *to_log) { | |
| 3427 | // first run the purge validations | ||
| 3428 |
1/2✓ Branch 0 taken 111 times.
✗ Branch 1 not taken.
|
111 | auto [is_invalid, invalid_error] = check_purge_conditions(mysql_bin_log); |
| 3429 |
3/4✓ Branch 0 taken 1 times.
✓ Branch 1 taken 110 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
111 | if (is_invalid) return purge_error_message(thd, invalid_error); |
| 3430 | |||
| 3431 | char search_file_name[FN_REFLEN]; | ||
| 3432 | 110 | constexpr auto auto_purge{false}; | |
| 3433 | 110 | constexpr auto include_to_log{false}; | |
| 3434 | 110 | constexpr auto need_index_lock{true}; | |
| 3435 | 110 | constexpr auto need_update_threads{true}; | |
| 3436 |
1/2✓ Branch 0 taken 110 times.
✗ Branch 1 not taken.
|
110 | mysql_bin_log.make_log_name(search_file_name, to_log); |
| 3437 |
1/2✓ Branch 0 taken 110 times.
✗ Branch 1 not taken.
|
110 | auto purge_error = mysql_bin_log.purge_logs( |
| 3438 | search_file_name, include_to_log, need_index_lock, need_update_threads, | ||
| 3439 | nullptr, auto_purge); | ||
| 3440 |
1/2✓ Branch 0 taken 110 times.
✗ Branch 1 not taken.
|
110 | return purge_error_message(thd, purge_error); |
| 3441 | } | ||
| 3442 | |||
| 3443 | /** | ||
| 3444 | Execute a PURGE BINARY LOGS BEFORE @<date@> command. | ||
| 3445 | |||
| 3446 | @param thd Pointer to THD object for the client thread executing the | ||
| 3447 | statement. | ||
| 3448 | |||
| 3449 | @param purge_time Date before which logs should be purged. | ||
| 3450 | |||
| 3451 | @retval false success | ||
| 3452 | @retval true failure | ||
| 3453 | */ | ||
| 3454 | 26 | bool purge_source_logs_before_date(THD *thd, time_t purge_time) { | |
| 3455 | // first run the purge validations | ||
| 3456 | 26 | const auto [is_invalid, invalid_error] = | |
| 3457 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | check_purge_conditions(mysql_bin_log); |
| 3458 |
3/4✓ Branch 0 taken 1 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
26 | if (is_invalid) return purge_error_message(thd, invalid_error); |
| 3459 | |||
| 3460 | // validations done, now purge | ||
| 3461 | 25 | constexpr auto auto_purge{false}; | |
| 3462 | auto purge_error = | ||
| 3463 |
1/2✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
|
25 | mysql_bin_log.purge_logs_before_date(purge_time, auto_purge); |
| 3464 |
1/2✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
|
25 | return purge_error_message(thd, purge_error); |
| 3465 | } | ||
| 3466 | |||
| 3467 | /** | ||
| 3468 | Check whether the instance is backup locked. | ||
| 3469 | |||
| 3470 | @retval 0 Instance is not backup locked | ||
| 3471 | @retval other Instance is backup locked or failure | ||
| 3472 | */ | ||
| 3473 | 7107 | int check_instance_backup_locked() { | |
| 3474 | 7107 | int res{0}; | |
| 3475 | |||
| 3476 | 7107 | auto is_instance_locked = is_instance_backup_locked(current_thd); | |
| 3477 |
2/4✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 7077 times.
✗ Branch 3 not taken.
|
7107 | switch (is_instance_locked) { |
| 3478 | ✗ | case Is_instance_backup_locked_result::OOM: | |
| 3479 | ✗ | res = LOG_INFO_MEM; | |
| 3480 | ✗ | break; | |
| 3481 | 30 | case Is_instance_backup_locked_result::LOCKED: | |
| 3482 | 30 | res = LOG_INFO_BACKUP_LOCK; | |
| 3483 | 30 | break; | |
| 3484 | 7077 | case Is_instance_backup_locked_result::NOT_LOCKED: | |
| 3485 | 7077 | break; | |
| 3486 | } | ||
| 3487 | |||
| 3488 | 7107 | return res; | |
| 3489 | } | ||
| 3490 | |||
| 3491 | /* | ||
| 3492 | Helper function to get the error code of the query to be binlogged. | ||
| 3493 | */ | ||
| 3494 | 88703 | int query_error_code(const THD *thd, bool not_killed) { | |
| 3495 | int error; | ||
| 3496 | |||
| 3497 |
2/2✓ Branch 0 taken 88686 times.
✓ Branch 1 taken 17 times.
|
88703 | if (not_killed) { |
| 3498 |
2/2✓ Branch 0 taken 876 times.
✓ Branch 1 taken 87811 times.
|
88686 | error = thd->is_error() ? thd->get_stmt_da()->mysql_errno() : 0; |
| 3499 | |||
| 3500 | /* thd->get_stmt_da()->sql_errno() might be ER_SERVER_SHUTDOWN or | ||
| 3501 | ER_QUERY_INTERRUPTED, So here we need to make sure that error | ||
| 3502 | is not set to these errors when specified not_killed by the | ||
| 3503 | caller. | ||
| 3504 | */ | ||
| 3505 |
2/4✓ Branch 0 taken 88687 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 88687 times.
|
88687 | if (error == ER_SERVER_SHUTDOWN || error == ER_QUERY_INTERRUPTED) error = 0; |
| 3506 | } else | ||
| 3507 | 17 | error = thd->killed; | |
| 3508 | |||
| 3509 | 88704 | return error; | |
| 3510 | } | ||
| 3511 | |||
| 3512 | /** | ||
| 3513 | Copy content of 'from' file from offset to 'to' file. | ||
| 3514 | |||
| 3515 | - We do the copy outside of the IO_CACHE as the cache | ||
| 3516 | buffers would just make things slower and more complicated. | ||
| 3517 | In most cases the copy loop should only do one read. | ||
| 3518 | |||
| 3519 | @param from File to copy. | ||
| 3520 | @param to File to copy to. | ||
| 3521 | @param offset Offset in 'from' file. | ||
| 3522 | |||
| 3523 | |||
| 3524 | @retval | ||
| 3525 | 0 ok | ||
| 3526 | @retval | ||
| 3527 | -1 error | ||
| 3528 | */ | ||
| 3529 | 102886 | static bool copy_file(IO_CACHE *from, IO_CACHE *to, my_off_t offset) { | |
| 3530 | int bytes_read; | ||
| 3531 | uchar io_buf[IO_SIZE * 2]; | ||
| 3532 |
1/2✓ Branch 0 taken 102886 times.
✗ Branch 1 not taken.
|
102886 | DBUG_TRACE; |
| 3533 | |||
| 3534 |
1/2✓ Branch 0 taken 102886 times.
✗ Branch 1 not taken.
|
102886 | mysql_file_seek(from->file, offset, MY_SEEK_SET, MYF(0)); |
| 3535 | while (true) { | ||
| 3536 |
1/2✓ Branch 0 taken 175651 times.
✗ Branch 1 not taken.
|
175651 | if ((bytes_read = (int)mysql_file_read(from->file, io_buf, sizeof(io_buf), |
| 3537 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 175651 times.
|
175651 | MYF(MY_WME))) < 0) |
| 3538 | ✗ | goto err; | |
| 3539 |
2/4✓ Branch 0 taken 175651 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 175651 times.
|
175651 | if (DBUG_EVALUATE_IF("fault_injection_copy_part_file", 1, 0)) |
| 3540 | ✗ | bytes_read = bytes_read / 2; | |
| 3541 |
2/2✓ Branch 0 taken 102885 times.
✓ Branch 1 taken 72766 times.
|
175651 | if (!bytes_read) break; // end of file |
| 3542 |
3/4✓ Branch 0 taken 72766 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 72765 times.
|
72766 | if (mysql_file_write(to->file, io_buf, bytes_read, MYF(MY_WME | MY_NABP))) |
| 3543 | 1 | goto err; | |
| 3544 | } | ||
| 3545 | |||
| 3546 | 102885 | return false; | |
| 3547 | |||
| 3548 | 1 | err: | |
| 3549 | 1 | return true; | |
| 3550 | 102886 | } | |
| 3551 | |||
| 3552 | /** | ||
| 3553 | Load data's io cache specific hook to be executed | ||
| 3554 | before a chunk of data is being read into the cache's buffer | ||
| 3555 | The function instantiates and writes into the binlog | ||
| 3556 | replication events along LOAD DATA processing. | ||
| 3557 | |||
| 3558 | @param file pointer to io-cache | ||
| 3559 | @retval 0 success | ||
| 3560 | @retval 1 failure | ||
| 3561 | */ | ||
| 3562 | 128068 | int log_loaded_block(IO_CACHE *file) { | |
| 3563 |
1/2✓ Branch 0 taken 128069 times.
✗ Branch 1 not taken.
|
128068 | DBUG_TRACE; |
| 3564 | LOAD_FILE_INFO *lf_info; | ||
| 3565 | uint block_len; | ||
| 3566 | /* buffer contains position where we started last read */ | ||
| 3567 | 128069 | uchar *buffer = (uchar *)my_b_get_buffer_start(file); | |
| 3568 |
1/2✓ Branch 0 taken 128069 times.
✗ Branch 1 not taken.
|
128069 | uint max_event_size = current_thd->variables.max_allowed_packet; |
| 3569 | 128069 | lf_info = (LOAD_FILE_INFO *)file->arg; | |
| 3570 |
2/2✓ Branch 0 taken 115916 times.
✓ Branch 1 taken 12152 times.
|
128069 | if (lf_info->thd->is_current_stmt_binlog_format_row()) return 0; |
| 3571 |
6/6✓ Branch 0 taken 4098 times.
✓ Branch 1 taken 8054 times.
✓ Branch 2 taken 4008 times.
✓ Branch 3 taken 90 times.
✓ Branch 4 taken 4008 times.
✓ Branch 5 taken 8144 times.
|
16250 | if (lf_info->last_pos_in_file != HA_POS_ERROR && |
| 3572 | 4098 | lf_info->last_pos_in_file >= my_b_get_pos_in_file(file)) | |
| 3573 | 4008 | return 0; | |
| 3574 | |||
| 3575 |
2/2✓ Branch 0 taken 4120 times.
✓ Branch 1 taken 8144 times.
|
12264 | for (block_len = (uint)(my_b_get_bytes_in_buffer(file)); block_len > 0; |
| 3576 | 4120 | buffer += min(block_len, max_event_size), | |
| 3577 | 4120 | block_len -= min(block_len, max_event_size)) { | |
| 3578 | 4120 | lf_info->last_pos_in_file = my_b_get_pos_in_file(file); | |
| 3579 |
2/2✓ Branch 0 taken 93 times.
✓ Branch 1 taken 4027 times.
|
4120 | if (lf_info->logged_data_file) { |
| 3580 | 186 | Append_block_log_event a(lf_info->thd, lf_info->thd->db().str, buffer, | |
| 3581 | 93 | min(block_len, max_event_size), | |
| 3582 |
1/2✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
|
93 | lf_info->log_delayed); |
| 3583 |
2/4✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 93 times.
|
93 | if (mysql_bin_log.write_event(&a)) return 1; |
| 3584 |
1/2✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
|
93 | } else { |
| 3585 | 8054 | Begin_load_query_log_event b(lf_info->thd, lf_info->thd->db().str, buffer, | |
| 3586 | 4027 | min(block_len, max_event_size), | |
| 3587 |
1/2✓ Branch 0 taken 4027 times.
✗ Branch 1 not taken.
|
4027 | lf_info->log_delayed); |
| 3588 |
2/4✓ Branch 0 taken 4027 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4027 times.
|
4027 | if (mysql_bin_log.write_event(&b)) return 1; |
| 3589 | 4027 | lf_info->logged_data_file = true; | |
| 3590 |
1/2✓ Branch 0 taken 4027 times.
✗ Branch 1 not taken.
|
4027 | } |
| 3591 | } | ||
| 3592 | 8144 | return 0; | |
| 3593 | 128068 | } | |
| 3594 | |||
| 3595 | /* Helper function for SHOW BINLOG/RELAYLOG EVENTS */ | ||
| 3596 | template <class BINLOG_FILE_READER> | ||
| 3597 | 36092 | bool show_binlog_events(THD *thd, MYSQL_BIN_LOG *binary_log) { | |
| 3598 | 36092 | Protocol *protocol = thd->get_protocol(); | |
| 3599 | 36092 | List<Item> field_list; | |
| 3600 | 36092 | std::string errmsg; | |
| 3601 | 36092 | LOG_INFO linfo; | |
| 3602 | |||
| 3603 |
1/2✓ Branch 0 taken 18046 times.
✗ Branch 1 not taken.
|
36092 | DBUG_TRACE; |
| 3604 | |||
| 3605 |
3/4✓ Branch 0 taken 1253 times.
✓ Branch 1 taken 16793 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1253 times.
|
36092 | assert(thd->lex->sql_command == SQLCOM_SHOW_BINLOG_EVENTS || |
| 3606 | thd->lex->sql_command == SQLCOM_SHOW_RELAYLOG_EVENTS); | ||
| 3607 | |||
| 3608 |
2/2✓ Branch 0 taken 18040 times.
✓ Branch 1 taken 6 times.
|
36092 | if (binary_log->is_open()) { |
| 3609 | 36080 | LEX_MASTER_INFO *lex_mi = &thd->lex->mi; | |
| 3610 | 36080 | Query_expression *unit = thd->lex->unit; | |
| 3611 | ha_rows event_count, limit_start, limit_end; | ||
| 3612 | 36080 | my_off_t pos = | |
| 3613 | 36080 | max<my_off_t>(BIN_LOG_HEADER_SIZE, lex_mi->pos); // user-friendly | |
| 3614 | char search_file_name[FN_REFLEN], *name; | ||
| 3615 | 36080 | const char *log_file_name = lex_mi->log_file_name; | |
| 3616 | 36080 | Log_event *ev = nullptr; | |
| 3617 | |||
| 3618 |
1/2✓ Branch 0 taken 18040 times.
✗ Branch 1 not taken.
|
36080 | unit->set_limit(thd, thd->lex->current_query_block()); |
| 3619 | 36080 | limit_start = unit->offset_limit_cnt; | |
| 3620 | 36080 | limit_end = unit->select_limit_cnt; | |
| 3621 | |||
| 3622 | 36080 | name = search_file_name; | |
| 3623 |
2/2✓ Branch 0 taken 14284 times.
✓ Branch 1 taken 3756 times.
|
36080 | if (log_file_name) |
| 3624 |
1/2✓ Branch 0 taken 14284 times.
✗ Branch 1 not taken.
|
28568 | binary_log->make_log_name(search_file_name, log_file_name); |
| 3625 | else | ||
| 3626 | 7512 | name = nullptr; // Find first log | |
| 3627 | |||
| 3628 | 36080 | linfo.index_file_offset = 0; | |
| 3629 | |||
| 3630 |
3/4✓ Branch 0 taken 18040 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 18031 times.
|
36080 | if (binary_log->find_log_pos(&linfo, name, true /*need_lock_index=true*/)) { |
| 3631 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
18 | errmsg = "Could not find target log"; |
| 3632 | 52 | goto err; | |
| 3633 | } | ||
| 3634 | |||
| 3635 |
1/2✓ Branch 0 taken 18031 times.
✗ Branch 1 not taken.
|
36062 | mysql_mutex_lock(&thd->LOCK_thd_data); |
| 3636 | 36062 | thd->current_linfo = &linfo; | |
| 3637 |
1/2✓ Branch 0 taken 18031 times.
✗ Branch 1 not taken.
|
36062 | mysql_mutex_unlock(&thd->LOCK_thd_data); |
| 3638 | |||
| 3639 |
1/2✓ Branch 0 taken 18031 times.
✗ Branch 1 not taken.
|
36062 | BINLOG_FILE_READER binlog_file_reader( |
| 3640 | opt_source_verify_checksum, | ||
| 3641 | 36062 | std::max(thd->variables.max_allowed_packet, | |
| 3642 | 36062 | binlog_row_event_max_size + MAX_LOG_EVENT_HEADER)); | |
| 3643 | |||
| 3644 |
3/4✓ Branch 0 taken 18031 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 18014 times.
|
36062 | if (binlog_file_reader.open(linfo.log_file_name, pos)) { |
| 3645 |
2/4✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✗ Branch 3 not taken.
|
34 | errmsg = binlog_file_reader.get_error_str(); |
| 3646 | 34 | goto err; | |
| 3647 | } | ||
| 3648 | |||
| 3649 | /* | ||
| 3650 | Adjust the pos to the correct starting offset of an event after the | ||
| 3651 | specified position if it is an invalid starting offset. | ||
| 3652 | */ | ||
| 3653 | 36028 | pos = binlog_file_reader.position(); | |
| 3654 | |||
| 3655 | /* | ||
| 3656 | For 'in-active' binlog file, it is safe to read all events in it. But | ||
| 3657 | for 'active' binlog file, it is only safe to read the events before | ||
| 3658 | get_binlog_end_pos(). | ||
| 3659 | |||
| 3660 | Binlog rotation may happen after calling is_active(). In this case, | ||
| 3661 | end_pos will NOT be set to 0 while the file is actually not 'active'. | ||
| 3662 | It is safe, since 'end_pos' still expresses a correct position. | ||
| 3663 | */ | ||
| 3664 | 36028 | my_off_t end_pos = binary_log->get_binlog_end_pos(); | |
| 3665 |
3/4✓ Branch 0 taken 18014 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 230 times.
✓ Branch 3 taken 17784 times.
|
36028 | if (!binary_log->is_active(linfo.log_file_name)) end_pos = 0; |
| 3666 | |||
| 3667 |
2/4✓ Branch 0 taken 18014 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18014 times.
✗ Branch 3 not taken.
|
36028 | DEBUG_SYNC(thd, "after_show_binlog_event_found_file"); |
| 3668 | |||
| 3669 | /** | ||
| 3670 | Relaylog_file_reader and Binlog_file_reader are typedefs to | ||
| 3671 | Basic_binlog_file_reader whereas Relaylog_file_reader uses | ||
| 3672 | a Relaylog_ifile in the template instantiation and | ||
| 3673 | Binlog_file_reader uses a Binlog_ifile in the template | ||
| 3674 | instantiation. | ||
| 3675 | |||
| 3676 | Binlog_ifile and Relaylog_ifile differ only in the open() | ||
| 3677 | member function and they both derive from Basic_binlog_ifile. | ||
| 3678 | |||
| 3679 | Therefore, it is OK to cast to Binlog_file_reader here. | ||
| 3680 | |||
| 3681 | TODO: in the future investigate if some refactoring is needed | ||
| 3682 | here. Perhaps make the Iterator itself templated. | ||
| 3683 | */ | ||
| 3684 |
1/2✓ Branch 0 taken 18014 times.
✗ Branch 1 not taken.
|
36028 | binlog::tools::Iterator it( |
| 3685 | reinterpret_cast<Binlog_file_reader *>(&binlog_file_reader)); | ||
| 3686 | |||
| 3687 | /* | ||
| 3688 | Unpacked events shall copy their part of the buffer from uncompressed | ||
| 3689 | buffer (the cointainer, i.e., the buffer iterator goes out of scope | ||
| 3690 | once the events are inflated and put in a vector). However, it is | ||
| 3691 | unclear if the *buffer* from which events are deserialized is still | ||
| 3692 | needed for the porposes of displaying events in SHOW BINLOG/RELAYLOG | ||
| 3693 | EVENTS. | ||
| 3694 | */ | ||
| 3695 | 36028 | my_off_t last_log_pos = 0; | |
| 3696 |
4/6✓ Branch 0 taken 18014 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 207215 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 201246 times.
✓ Branch 5 taken 5969 times.
|
414430 | for (event_count = 0, ev = it.begin(); ev != it.end();) { |
| 3697 |
2/4✓ Branch 0 taken 201246 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 201246 times.
✗ Branch 3 not taken.
|
402492 | DEBUG_SYNC(thd, "wait_in_show_binlog_events_loop"); |
| 3698 |
3/4✓ Branch 0 taken 200998 times.
✓ Branch 1 taken 248 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 201246 times.
|
804488 | if (event_count >= limit_start && |
| 3699 |
2/4✓ Branch 0 taken 200998 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 200998 times.
|
401996 | ev->net_send(protocol, linfo.log_file_name, pos)) { |
| 3700 | /* purecov: begin inspected */ | ||
| 3701 | ✗ | errmsg = "Net error"; | |
| 3702 | ✗ | delete ev; | |
| 3703 | ✗ | ev = nullptr; | |
| 3704 | ✗ | goto err; | |
| 3705 | /* purecov: end */ | ||
| 3706 | } | ||
| 3707 | 402492 | last_log_pos = ev->common_header->log_pos; | |
| 3708 |
1/2✓ Branch 0 taken 201246 times.
✗ Branch 1 not taken.
|
402492 | delete ev; |
| 3709 | 402492 | ev = nullptr; | |
| 3710 | 402492 | pos = binlog_file_reader.position(); | |
| 3711 | |||
| 3712 |
2/2✓ Branch 0 taken 1499 times.
✓ Branch 1 taken 199747 times.
|
402492 | if (++event_count == limit_end) break; |
| 3713 |
4/6✓ Branch 0 taken 199747 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 199747 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10545 times.
✓ Branch 5 taken 189202 times.
|
399494 | if ((ev = it.next()) == it.end()) break; |
| 3714 |
2/4✓ Branch 0 taken 189202 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 189202 times.
|
378404 | if (it.has_error()) break; |
| 3715 |
4/4✓ Branch 0 taken 187647 times.
✓ Branch 1 taken 1555 times.
✓ Branch 2 taken 187 times.
✓ Branch 3 taken 187460 times.
|
378404 | if (end_pos > 0 && pos >= end_pos && |
| 3716 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 186 times.
|
374 | (ev->common_header->log_pos != last_log_pos)) { |
| 3717 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
2 | delete ev; |
| 3718 | 2 | ev = nullptr; | |
| 3719 | 2 | break; | |
| 3720 | } | ||
| 3721 | } | ||
| 3722 | |||
| 3723 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 18013 times.
|
36028 | if (binlog_file_reader.has_fatal_error()) |
| 3724 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
2 | errmsg = binlog_file_reader.get_error_str(); |
| 3725 |
2/4✓ Branch 0 taken 18013 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 18013 times.
|
36026 | else if (it.has_error()) |
| 3726 | ✗ | errmsg = it.get_error_message(); /* purecov: inspected */ | |
| 3727 | else | ||
| 3728 |
1/2✓ Branch 0 taken 18013 times.
✗ Branch 1 not taken.
|
36026 | errmsg = ""; |
| 3729 |
3/4✓ Branch 0 taken 18014 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18014 times.
✓ Branch 3 taken 17 times.
|
36062 | } |
| 3730 | // Check that linfo is still on the function scope. | ||
| 3731 |
2/4✗ Branch 0 not taken.
✓ Branch 1 taken 18020 times.
✓ Branch 2 taken 18020 times.
✗ Branch 3 not taken.
|
36040 | DEBUG_SYNC(thd, "after_show_binlog_events"); |
| 3732 | |||
| 3733 | ✗ | err: | |
| 3734 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 18019 times.
|
36092 | if (!errmsg.empty()) { |
| 3735 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 25 times.
|
54 | if (thd->lex->sql_command == SQLCOM_SHOW_RELAYLOG_EVENTS) |
| 3736 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
4 | my_error(ER_ERROR_WHEN_EXECUTING_COMMAND, MYF(0), "SHOW RELAYLOG EVENTS", |
| 3737 | errmsg.c_str()); | ||
| 3738 | else | ||
| 3739 |
1/2✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
|
50 | my_error(ER_ERROR_WHEN_EXECUTING_COMMAND, MYF(0), "SHOW BINLOG EVENTS", |
| 3740 | errmsg.c_str()); | ||
| 3741 | } else | ||
| 3742 |
1/2✓ Branch 0 taken 18019 times.
✗ Branch 1 not taken.
|
36038 | my_eof(thd); |
| 3743 | |||
| 3744 |
1/2✓ Branch 0 taken 18046 times.
✗ Branch 1 not taken.
|
36092 | mysql_mutex_lock(&thd->LOCK_thd_data); |
| 3745 | 36092 | thd->current_linfo = nullptr; | |
| 3746 |
1/2✓ Branch 0 taken 18046 times.
✗ Branch 1 not taken.
|
36092 | mysql_mutex_unlock(&thd->LOCK_thd_data); |
| 3747 | 72184 | return !errmsg.empty(); | |
| 3748 | 36092 | } | |
| 3749 | |||
| 3750 | 18046 | bool show_binlog_events(THD *thd, MYSQL_BIN_LOG *binary_log) { | |
| 3751 |
2/2✓ Branch 0 taken 1253 times.
✓ Branch 1 taken 16793 times.
|
18046 | if (binary_log->is_relay_log) |
| 3752 | 1253 | return show_binlog_events<Relaylog_file_reader>(thd, binary_log); | |
| 3753 | 16793 | return show_binlog_events<Binlog_file_reader>(thd, binary_log); | |
| 3754 | } | ||
| 3755 | |||
| 3756 | /** | ||
| 3757 | Execute a SHOW BINLOG EVENTS statement. | ||
| 3758 | |||
| 3759 | @param thd Pointer to THD object for the client thread executing the | ||
| 3760 | statement. | ||
| 3761 | |||
| 3762 | @retval false success | ||
| 3763 | @retval true failure | ||
| 3764 | */ | ||
| 3765 | 16793 | bool mysql_show_binlog_events(THD *thd) { | |
| 3766 |
1/2✓ Branch 0 taken 16793 times.
✗ Branch 1 not taken.
|
16793 | DBUG_TRACE; |
| 3767 | |||
| 3768 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16793 times.
|
16793 | assert(thd->lex->sql_command == SQLCOM_SHOW_BINLOG_EVENTS); |
| 3769 | |||
| 3770 | 16793 | mem_root_deque<Item *> field_list(thd->mem_root); | |
| 3771 |
1/2✓ Branch 0 taken 16793 times.
✗ Branch 1 not taken.
|
16793 | Log_event::init_show_field_list(&field_list); |
| 3772 |
2/4✓ Branch 0 taken 16793 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16793 times.
|
16793 | if (thd->send_result_metadata(field_list, |
| 3773 | Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) | ||
| 3774 | ✗ | return true; | |
| 3775 | |||
| 3776 | /* | ||
| 3777 | Wait for handlers to insert any pending information | ||
| 3778 | into the binlog. For e.g. ndb which updates the binlog asynchronously | ||
| 3779 | this is needed so that the uses sees all its own commands in the binlog | ||
| 3780 | */ | ||
| 3781 |
1/2✓ Branch 0 taken 16793 times.
✗ Branch 1 not taken.
|
16793 | ha_binlog_wait(thd); |
| 3782 | |||
| 3783 |
1/2✓ Branch 0 taken 16793 times.
✗ Branch 1 not taken.
|
16793 | return show_binlog_events(thd, &mysql_bin_log); |
| 3784 | 16793 | } | |
| 3785 | |||
| 3786 | 129882 | MYSQL_BIN_LOG::MYSQL_BIN_LOG(uint *sync_period, bool relay_log) | |
| 3787 | 129882 | : name(nullptr), | |
| 3788 | 129882 | write_error(false), | |
| 3789 | 129882 | inited(false), | |
| 3790 |
1/2✓ Branch 0 taken 129883 times.
✗ Branch 1 not taken.
|
129882 | m_binlog_file(new Binlog_ofile()), |
| 3791 | 129882 | m_key_LOCK_log(key_LOG_LOCK_log), | |
| 3792 | 129882 | bytes_written(0), | |
| 3793 | 129882 | binlog_space_total(0), | |
| 3794 | 129882 | file_id(1), | |
| 3795 | 129882 | sync_period_ptr(sync_period), | |
| 3796 | 129882 | sync_counter(0), | |
| 3797 | 129882 | is_relay_log(relay_log), | |
| 3798 | 129882 | checksum_alg_reset(binary_log::BINLOG_CHECKSUM_ALG_UNDEF), | |
| 3799 | 129882 | relay_log_checksum_alg(binary_log::BINLOG_CHECKSUM_ALG_UNDEF), | |
| 3800 | 129881 | previous_gtid_set_relaylog(nullptr), | |
| 3801 | 129881 | snapshot_lock_acquired(false), | |
| 3802 |
1/2✓ Branch 0 taken 129882 times.
✗ Branch 1 not taken.
|
259764 | is_rotating_caused_by_incident(false) { |
| 3803 | /* | ||
| 3804 | We don't want to initialize locks here as such initialization depends on | ||
| 3805 | safe_mutex (when using safe_mutex) which depends on MY_INIT(), which is | ||
| 3806 | called only in main(). Doing initialization here would make it happen | ||
| 3807 | before main(). | ||
| 3808 | */ | ||
| 3809 | 129881 | index_file_name[0] = 0; | |
| 3810 | 129881 | } | |
| 3811 | |||
| 3812 |
2/2✓ Branch 0 taken 98885 times.
✓ Branch 1 taken 26800 times.
|
251370 | MYSQL_BIN_LOG::~MYSQL_BIN_LOG() { delete m_binlog_file; } |
| 3813 | |||
| 3814 | /* this is called only once */ | ||
| 3815 | |||
| 3816 | 26802 | void MYSQL_BIN_LOG::cleanup() { | |
| 3817 |
1/2✓ Branch 0 taken 26802 times.
✗ Branch 1 not taken.
|
26802 | DBUG_TRACE; |
| 3818 |
2/2✓ Branch 0 taken 26800 times.
✓ Branch 1 taken 2 times.
|
26802 | if (inited) { |
| 3819 | 26800 | inited = false; | |
| 3820 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT, true /*need_lock_log=true*/, |
| 3821 | true /*need_lock_index=true*/); | ||
| 3822 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | mysql_mutex_destroy(&LOCK_log); |
| 3823 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | mysql_mutex_destroy(&LOCK_index); |
| 3824 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | mysql_mutex_destroy(&LOCK_commit); |
| 3825 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | mysql_mutex_destroy(&LOCK_sync); |
| 3826 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | mysql_mutex_destroy(&LOCK_binlog_end_pos); |
| 3827 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | mysql_mutex_destroy(&LOCK_xids); |
| 3828 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | mysql_cond_destroy(&update_cond); |
| 3829 |
1/2✓ Branch 0 taken 26800 times.
✗ Branch 1 not taken.
|
26800 | mysql_cond_destroy(&m_prep_xids_cond); |
| 3830 |
2/2✓ Branch 0 taken 8468 times.
✓ Branch 1 taken 18332 times.
|
26800 | if (!is_relay_log) { |
| 3831 |
2/4✓ Branch 0 taken 8468 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8468 times.
✗ Branch 3 not taken.
|
8468 | Commit_stage_manager::get_instance().deinit(); |
| 3832 | } | ||
| 3833 | } | ||
| 3834 | |||
| 3835 |
2/2✓ Branch 0 taken 26800 times.
✓ Branch 1 taken 2 times.
|
26802 | delete m_binlog_file; |
| 3836 | 26802 | m_binlog_file = nullptr; | |
| 3837 | 26802 | } | |
| 3838 | |||
| 3839 | 29501 | void MYSQL_BIN_LOG::init_pthread_objects() { | |
| 3840 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29501 times.
|
29501 | assert(inited == 0); |
| 3841 | 29501 | inited = true; | |
| 3842 | |||
| 3843 | 29501 | mysql_mutex_init(m_key_LOCK_log, &LOCK_log, MY_MUTEX_INIT_SLOW); | |
| 3844 | 29501 | mysql_mutex_init(m_key_LOCK_index, &LOCK_index, MY_MUTEX_INIT_SLOW); | |
| 3845 | 29501 | mysql_mutex_init(m_key_LOCK_commit, &LOCK_commit, MY_MUTEX_INIT_FAST); | |
| 3846 | 29501 | mysql_mutex_init(m_key_LOCK_sync, &LOCK_sync, MY_MUTEX_INIT_FAST); | |
| 3847 | 29501 | mysql_mutex_init(m_key_LOCK_binlog_end_pos, &LOCK_binlog_end_pos, | |
| 3848 | MY_MUTEX_INIT_FAST); | ||
| 3849 | 29501 | mysql_mutex_init(m_key_LOCK_xids, &LOCK_xids, MY_MUTEX_INIT_FAST); | |
| 3850 | 29501 | mysql_cond_init(m_key_update_cond, &update_cond); | |
| 3851 | 29501 | mysql_cond_init(m_key_prep_xids_cond, &m_prep_xids_cond); | |
| 3852 |
2/2✓ Branch 0 taken 9824 times.
✓ Branch 1 taken 19677 times.
|
29501 | if (!is_relay_log) { |
| 3853 | 9824 | Commit_stage_manager::get_instance().init( | |
| 3854 | m_key_LOCK_flush_queue, m_key_LOCK_sync_queue, m_key_LOCK_commit_queue, | ||
| 3855 | m_key_LOCK_done, m_key_COND_done, m_key_COND_flush_queue); | ||
| 3856 | } | ||
| 3857 | 29501 | } | |
| 3858 | |||
| 3859 | /** | ||
| 3860 | Check if a string is a valid number. | ||
| 3861 | |||
| 3862 | @param str String to test | ||
| 3863 | @param res Store value here | ||
| 3864 | @param allow_wildcards Set to 1 if we should ignore '%' and '_' | ||
| 3865 | |||
| 3866 | @note | ||
| 3867 | For the moment the allow_wildcards argument is not used | ||
| 3868 | Should be moved to some other file. | ||
| 3869 | |||
| 3870 | @retval | ||
| 3871 | 1 String is a number | ||
| 3872 | @retval | ||
| 3873 | 0 String is not a number | ||
| 3874 | */ | ||
| 3875 | |||
| 3876 | 4546896 | static bool is_number(const char *str, ulong *res, bool allow_wildcards) { | |
| 3877 | int flag; | ||
| 3878 | const char *start; | ||
| 3879 |
1/2✓ Branch 0 taken 4546896 times.
✗ Branch 1 not taken.
|
4546896 | DBUG_TRACE; |
| 3880 | |||
| 3881 | 4546896 | flag = 0; | |
| 3882 | 4546896 | start = str; | |
| 3883 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4546896 times.
|
4546896 | while (*str++ == ' ') |
| 3884 | ; | ||
| 3885 |
3/6✓ Branch 0 taken 4546896 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4546896 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 4546896 times.
|
4546896 | if (*--str == '-' || *str == '+') str++; |
| 3886 |
3/4✓ Branch 0 taken 26242959 times.
✓ Branch 1 taken 4546896 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4546896 times.
|
30789855 | while (my_isdigit(files_charset_info, *str) || |
| 3887 | ✗ | (allow_wildcards && (*str == wild_many || *str == wild_one))) { | |
| 3888 | 26242959 | flag = 1; | |
| 3889 | 26242959 | str++; | |
| 3890 | } | ||
| 3891 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 4546886 times.
|
4546896 | if (*str == '.') { |
| 3892 |
2/4✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
|
10 | for (str++; my_isdigit(files_charset_info, *str) || |
| 3893 | ✗ | (allow_wildcards && (*str == wild_many || *str == wild_one)); | |
| 3894 | ✗ | str++, flag = 1) | |
| 3895 | ; | ||
| 3896 | } | ||
| 3897 |
3/4✓ Branch 0 taken 4373803 times.
✓ Branch 1 taken 173093 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4373803 times.
|
4546896 | if (*str != 0 || flag == 0) return false; |
| 3898 |
1/2✓ Branch 0 taken 4373804 times.
✗ Branch 1 not taken.
|
4373803 | if (res) *res = atol(start); |
| 3899 | 4373803 | return true; /* Number ok */ | |
| 3900 | 4546896 | } /* is_number */ | |
| 3901 | |||
| 3902 | /** | ||
| 3903 | Find a unique filename for 'filename.#'. | ||
| 3904 | |||
| 3905 | Set '#' to the highest existing log file extension plus one. | ||
| 3906 | |||
| 3907 | This function will return nonzero if: (i) the generated name | ||
| 3908 | exceeds FN_REFLEN; (ii) if the number of extensions is exhausted; | ||
| 3909 | or (iii) some other error happened while examining the filesystem. | ||
| 3910 | |||
| 3911 | @return | ||
| 3912 | nonzero if not possible to get unique filename. | ||
| 3913 | */ | ||
| 3914 | |||
| 3915 | 125988 | static int find_uniq_filename(char *name, uint32 new_index_number) { | |
| 3916 | uint i; | ||
| 3917 | char buff[FN_REFLEN], ext_buf[FN_REFLEN]; | ||
| 3918 | 125988 | MY_DIR *dir_info = nullptr; | |
| 3919 | struct fileinfo *file_info; | ||
| 3920 | 125988 | ulong max_found = 0, next = 0, number = 0; | |
| 3921 | size_t buf_length, length; | ||
| 3922 | char *start, *end; | ||
| 3923 | 125988 | int error = 0; | |
| 3924 |
1/2✓ Branch 0 taken 125988 times.
✗ Branch 1 not taken.
|
125988 | DBUG_TRACE; |
| 3925 | |||
| 3926 |
1/2✓ Branch 0 taken 125988 times.
✗ Branch 1 not taken.
|
125988 | length = dirname_part(buff, name, &buf_length); |
| 3927 | 125988 | start = name + length; | |
| 3928 | 125988 | end = strend(start); | |
| 3929 | |||
| 3930 | 125988 | *end = '.'; | |
| 3931 | 125988 | length = (size_t)(end - start + 1); | |
| 3932 | |||
| 3933 |
7/10✓ Branch 0 taken 125988 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 125975 times.
✓ Branch 3 taken 13 times.
✓ Branch 4 taken 125974 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 125974 times.
✓ Branch 8 taken 13 times.
✓ Branch 9 taken 125974 times.
|
125988 | if ((DBUG_EVALUATE_IF( |
| 3934 | "error_unique_log_filename", 1, | ||
| 3935 | !(dir_info = | ||
| 3936 | my_dir(buff, MYF(MY_DONT_SORT)))))) { // This shouldn't happen | ||
| 3937 | 13 | my_stpcpy(end, ".1"); // use name+1 | |
| 3938 | 13 | return 1; | |
| 3939 | } | ||
| 3940 | 125974 | file_info = dir_info->dir_entry; | |
| 3941 |
2/2✓ Branch 0 taken 7369653 times.
✓ Branch 1 taken 125973 times.
|
7495626 | for (i = dir_info->number_off_files; i--; file_info++) { |
| 3942 |
4/4✓ Branch 0 taken 4546895 times.
✓ Branch 1 taken 2822758 times.
✓ Branch 2 taken 4373801 times.
✓ Branch 3 taken 2995851 times.
|
11916547 | if (strncmp(file_info->name, start, length) == 0 && |
| 3943 |
3/4✓ Branch 0 taken 4546894 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4373801 times.
✓ Branch 3 taken 173093 times.
|
4546895 | is_number(file_info->name + length, &number, false)) { |
| 3944 | 4373801 | max_found = std::max(max_found, number); | |
| 3945 | } | ||
| 3946 | } | ||
| 3947 |
1/2✓ Branch 0 taken 125974 times.
✗ Branch 1 not taken.
|
125973 | my_dirend(dir_info); |
| 3948 | |||
| 3949 | /* check if reached the maximum possible extension number */ | ||
| 3950 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 125969 times.
|
125974 | if (max_found >= MAX_LOG_UNIQUE_FN_EXT) { |
| 3951 |
8/16✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 5 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 5 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 5 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 5 times.
✗ Branch 15 not taken.
|
5 | LogErr(ERROR_LEVEL, ER_BINLOG_FILE_EXTENSION_NUMBER_EXHAUSTED, max_found); |
| 3952 | 5 | error = 1; | |
| 3953 | 5 | goto end; | |
| 3954 | } | ||
| 3955 | |||
| 3956 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 125957 times.
|
125969 | if (new_index_number > 0) { |
| 3957 | /* | ||
| 3958 | If "new_index_number" was specified, this means we are handling a | ||
| 3959 | "RESET MASTER TO" command and the binary log was already purged | ||
| 3960 | so max_found should be 0. | ||
| 3961 | */ | ||
| 3962 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | assert(max_found == 0); |
| 3963 | 12 | next = new_index_number; | |
| 3964 | } else | ||
| 3965 | 125957 | next = max_found + 1; | |
| 3966 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 125969 times.
|
125969 | if (sprintf(ext_buf, "%06lu", next) < 0) { |
| 3967 | ✗ | error = 1; | |
| 3968 | ✗ | goto end; | |
| 3969 | } | ||
| 3970 | 125969 | *end++ = '.'; | |
| 3971 | |||
| 3972 | /* | ||
| 3973 | Check if the generated extension size + the file name exceeds the | ||
| 3974 | buffer size used. If one did not check this, then the filename might be | ||
| 3975 | truncated, resulting in error. | ||
| 3976 | */ | ||
| 3977 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 125969 times.
|
125969 | if (((strlen(ext_buf) + (end - name)) >= FN_REFLEN)) { |
| 3978 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FILE_NAME_TOO_LONG, name, ext_buf, | |
| 3979 | (strlen(ext_buf) + (end - name))); | ||
| 3980 | ✗ | error = 1; | |
| 3981 | ✗ | goto end; | |
| 3982 | } | ||
| 3983 | |||
| 3984 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 125969 times.
|
125969 | if (sprintf(end, "%06lu", next) < 0) { |
| 3985 | ✗ | error = 1; | |
| 3986 | ✗ | goto end; | |
| 3987 | } | ||
| 3988 | |||
| 3989 | /* print warning if reaching the end of available extensions. */ | ||
| 3990 |
2/2✓ Branch 0 taken 125961 times.
✓ Branch 1 taken 8 times.
|
125969 | if (next > MAX_ALLOWED_FN_EXT_RESET_MASTER) |
| 3991 |
8/16✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 8 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 8 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 8 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 8 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 8 times.
✗ Branch 15 not taken.
|
8 | LogErr(WARNING_LEVEL, ER_BINLOG_FILE_EXTENSION_NUMBER_RUNNING_LOW, next, |
| 3992 | (MAX_LOG_UNIQUE_FN_EXT - next)); | ||
| 3993 | |||
| 3994 | 125961 | end: | |
| 3995 | 125974 | return error; | |
| 3996 | 125987 | } | |
| 3997 | |||
| 3998 | 125988 | int MYSQL_BIN_LOG::generate_new_name(char *new_name, const char *log_name, | |
| 3999 | uint32 new_index_number) { | ||
| 4000 | 125988 | fn_format(new_name, log_name, mysql_data_home, "", 4); | |
| 4001 |
1/2✓ Branch 0 taken 125988 times.
✗ Branch 1 not taken.
|
125988 | if (!fn_ext(log_name)[0]) { |
| 4002 |
2/2✓ Branch 0 taken 19 times.
✓ Branch 1 taken 125968 times.
|
125988 | if (find_uniq_filename(new_name, new_index_number)) { |
| 4003 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.
|
19 | if (current_thd != nullptr) |
| 4004 | 16 | my_printf_error(ER_NO_UNIQUE_LOGFILE, | |
| 4005 | 16 | ER_THD(current_thd, ER_NO_UNIQUE_LOGFILE), | |
| 4006 | MYF(ME_FATALERROR), log_name); | ||
| 4007 |
7/14✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 18 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 18 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 18 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 18 times.
✗ Branch 13 not taken.
|
18 | LogErr(ERROR_LEVEL, ER_FAILED_TO_GENERATE_UNIQUE_LOGFILE, log_name); |
| 4008 | 18 | return 1; | |
| 4009 | } | ||
| 4010 | } | ||
| 4011 | 125968 | return 0; | |
| 4012 | } | ||
| 4013 | |||
| 4014 | /** | ||
| 4015 | @todo | ||
| 4016 | The following should be using fn_format(); We just need to | ||
| 4017 | first change fn_format() to cut the file name if it's too long. | ||
| 4018 | */ | ||
| 4019 | 21088 | const char *MYSQL_BIN_LOG::generate_name(const char *log_name, | |
| 4020 | const char *suffix, char *buff) { | ||
| 4021 |
3/4✓ Branch 0 taken 16127 times.
✓ Branch 1 taken 4961 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16127 times.
|
21088 | if (!log_name || !log_name[0]) { |
| 4022 |
3/4✓ Branch 0 taken 4961 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 46 times.
✓ Branch 3 taken 4915 times.
|
4961 | if (is_relay_log || log_bin_supplied) |
| 4023 | 46 | strmake(buff, default_logfile_name, FN_REFLEN - strlen(suffix) - 1); | |
| 4024 | else | ||
| 4025 | 4915 | strmake(buff, default_binlogfile_name, FN_REFLEN - strlen(suffix) - 1); | |
| 4026 | |||
| 4027 | 4961 | return (const char *)fn_format(buff, buff, "", suffix, | |
| 4028 | 4961 | MYF(MY_REPLACE_EXT | MY_REPLACE_DIR)); | |
| 4029 | } | ||
| 4030 | // get rid of extension to avoid problems | ||
| 4031 | |||
| 4032 | 16127 | const char *p = fn_ext(log_name); | |
| 4033 | 16127 | uint length = (uint)(p - log_name); | |
| 4034 |
1/2✓ Branch 0 taken 16127 times.
✗ Branch 1 not taken.
|
16127 | strmake(buff, log_name, min<size_t>(length, FN_REFLEN - 1)); |
| 4035 | 16127 | return (const char *)buff; | |
| 4036 | } | ||
| 4037 | |||
| 4038 | 157725 | bool MYSQL_BIN_LOG::init_and_set_log_file_name(const char *log_name, | |
| 4039 | const char *new_name, | ||
| 4040 | uint32 new_index_number) { | ||
| 4041 |
4/6✓ Branch 0 taken 63524 times.
✓ Branch 1 taken 94201 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 63524 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 157725 times.
|
157725 | if (new_name && !my_stpcpy(log_file_name, new_name)) |
| 4042 | ✗ | return true; | |
| 4043 |
4/4✓ Branch 0 taken 94202 times.
✓ Branch 1 taken 63523 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 157721 times.
|
251926 | else if (!new_name && |
| 4044 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 94198 times.
|
94202 | generate_new_name(log_file_name, log_name, new_index_number)) |
| 4045 | 3 | return true; | |
| 4046 | |||
| 4047 | 157721 | return false; | |
| 4048 | } | ||
| 4049 | |||
| 4050 | /** | ||
| 4051 | Open the logfile and init IO_CACHE. | ||
| 4052 | |||
| 4053 | @param log_file_key The file instrumentation key for this file | ||
| 4054 | @param log_name The name of the log to open | ||
| 4055 | @param new_name The new name for the logfile. | ||
| 4056 | NULL forces generate_new_name() to be called. | ||
| 4057 | @param new_index_number The binary log file index number to start from | ||
| 4058 | after the RESET MASTER TO command is called. | ||
| 4059 | |||
| 4060 | @return true if error, false otherwise. | ||
| 4061 | */ | ||
| 4062 | |||
| 4063 | 78860 | bool MYSQL_BIN_LOG::open(PSI_file_key log_file_key, const char *log_name, | |
| 4064 | const char *new_name, uint32 new_index_number) { | ||
| 4065 |
1/2✓ Branch 0 taken 78860 times.
✗ Branch 1 not taken.
|
78860 | DBUG_TRACE; |
| 4066 | 78860 | bool ret = false; | |
| 4067 | |||
| 4068 | 78860 | write_error = false; | |
| 4069 | 78860 | myf flags = MY_WME | MY_NABP | MY_WAIT_IF_FULL; | |
| 4070 |
2/2✓ Branch 0 taken 52759 times.
✓ Branch 1 taken 26101 times.
|
78860 | if (is_relay_log) flags = flags | MY_REPORT_WAITING_IF_FULL; |
| 4071 | |||
| 4072 |
2/4✓ Branch 0 taken 78860 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78860 times.
|
78860 | if (!(name = my_strdup(key_memory_MYSQL_LOG_name, log_name, MYF(MY_WME)))) { |
| 4073 | ✗ | goto err; | |
| 4074 | } | ||
| 4075 | |||
| 4076 |
4/6✓ Branch 0 taken 78859 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78859 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 78858 times.
|
157719 | if (init_and_set_log_file_name(name, new_name, new_index_number) || |
| 4077 |
3/4✓ Branch 0 taken 78859 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 78858 times.
|
78859 | DBUG_EVALUATE_IF("fault_injection_init_name", 1, 0)) |
| 4078 | 1 | goto err; | |
| 4079 | |||
| 4080 | 78858 | db[0] = 0; | |
| 4081 | |||
| 4082 | /* Keep the key for reopen */ | ||
| 4083 | 78858 | m_log_file_key = log_file_key; | |
| 4084 | |||
| 4085 | /* | ||
| 4086 | LOCK_sync guarantees that no thread is calling m_binlog_file to sync data | ||
| 4087 | to disk when another thread is opening the new file | ||
| 4088 | (FLUSH LOG or RESET MASTER). | ||
| 4089 | */ | ||
| 4090 |
3/4✓ Branch 0 taken 26099 times.
✓ Branch 1 taken 52759 times.
✓ Branch 2 taken 26099 times.
✗ Branch 3 not taken.
|
78858 | if (!is_relay_log) mysql_mutex_lock(&LOCK_sync); |
| 4091 | |||
| 4092 |
1/2✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
|
78858 | ret = m_binlog_file->open(log_file_key, log_file_name, flags); |
| 4093 | |||
| 4094 |
3/4✓ Branch 0 taken 26099 times.
✓ Branch 1 taken 52759 times.
✓ Branch 2 taken 26099 times.
✗ Branch 3 not taken.
|
78858 | if (!is_relay_log) mysql_mutex_unlock(&LOCK_sync); |
| 4095 | |||
| 4096 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78858 times.
|
78858 | if (ret) goto err; |
| 4097 | |||
| 4098 | 78858 | atomic_log_state = LOG_OPENED; | |
| 4099 | 78858 | return false; | |
| 4100 | |||
| 4101 | 1 | err: | |
| 4102 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (binlog_error_action == ABORT_SERVER) { |
| 4103 | ✗ | exec_binlog_error_action_abort( | |
| 4104 | "Either disk is full, file system is read only or " | ||
| 4105 | "there was an encryption error while opening the binlog. " | ||
| 4106 | "Aborting the server."); | ||
| 4107 | } else | ||
| 4108 |
8/16✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
|
1 | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_FOR_LOGGING, log_name, errno); |
| 4109 | |||
| 4110 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_free(name); |
| 4111 | 1 | name = nullptr; | |
| 4112 | 1 | atomic_log_state = LOG_CLOSED; | |
| 4113 | 1 | return true; | |
| 4114 | 78859 | } | |
| 4115 | |||
| 4116 | 79082 | bool MYSQL_BIN_LOG::open_index_file(const char *index_file_name_arg, | |
| 4117 | const char *log_name, | ||
| 4118 | bool need_lock_index) { | ||
| 4119 | 79082 | bool error = false; | |
| 4120 | 79082 | File index_file_nr = -1; | |
| 4121 |
2/2✓ Branch 0 taken 21051 times.
✓ Branch 1 taken 58031 times.
|
79082 | if (need_lock_index) |
| 4122 | 21051 | mysql_mutex_lock(&LOCK_index); | |
| 4123 | else | ||
| 4124 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 4125 | |||
| 4126 | /* | ||
| 4127 | First open of this class instance | ||
| 4128 | Create an index file that will hold all file names uses for logging. | ||
| 4129 | Add new entries to the end of it. | ||
| 4130 | */ | ||
| 4131 | 79082 | myf opt = MY_UNPACK_FILENAME; | |
| 4132 | |||
| 4133 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 79081 times.
|
79082 | if (my_b_inited(&index_file)) goto end; |
| 4134 | |||
| 4135 |
2/2✓ Branch 0 taken 21029 times.
✓ Branch 1 taken 58052 times.
|
79081 | if (!index_file_name_arg) { |
| 4136 | 21029 | index_file_name_arg = log_name; // Use same basename for index file | |
| 4137 | 21029 | opt = MY_UNPACK_FILENAME | MY_REPLACE_EXT; | |
| 4138 | } | ||
| 4139 | 79081 | fn_format(index_file_name, index_file_name_arg, mysql_data_home, ".index", | |
| 4140 | opt); | ||
| 4141 | |||
| 4142 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79081 times.
|
79081 | if (set_crash_safe_index_file_name(index_file_name_arg)) { |
| 4143 | ✗ | error = true; | |
| 4144 | ✗ | goto end; | |
| 4145 | } | ||
| 4146 | |||
| 4147 | /* | ||
| 4148 | We need move crash_safe_index_file to index_file if the index_file | ||
| 4149 | does not exist and crash_safe_index_file exists when mysqld server | ||
| 4150 | restarts. | ||
| 4151 | */ | ||
| 4152 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 35676 times.
|
114757 | if (my_access(index_file_name, F_OK) && |
| 4153 |
3/4✓ Branch 0 taken 35676 times.
✓ Branch 1 taken 43405 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 79081 times.
|
114757 | !my_access(crash_safe_index_file_name, F_OK) && |
| 4154 | ✗ | my_rename(crash_safe_index_file_name, index_file_name, MYF(MY_WME))) { | |
| 4155 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_MOVE_TMP_TO_INDEX, | |
| 4156 | "MYSQL_BIN_LOG::open_index_file"); | ||
| 4157 | ✗ | error = true; | |
| 4158 | ✗ | goto end; | |
| 4159 | } | ||
| 4160 | |||
| 4161 | 79081 | if ((index_file_nr = mysql_file_open(m_key_file_log_index, index_file_name, | |
| 4162 | 79080 | O_RDWR | O_CREAT, MYF(MY_WME))) < 0 || | |
| 4163 |
1/2✓ Branch 0 taken 79080 times.
✗ Branch 1 not taken.
|
79080 | mysql_file_sync(index_file_nr, MYF(MY_WME)) || |
| 4164 |
1/2✓ Branch 0 taken 79080 times.
✗ Branch 1 not taken.
|
79080 | init_io_cache_ext(&index_file, index_file_nr, IO_SIZE, READ_CACHE, |
| 4165 | mysql_file_seek(index_file_nr, 0L, MY_SEEK_END, MYF(0)), | ||
| 4166 | false, MYF(MY_WME | MY_WAIT_IF_FULL), | ||
| 4167 |
4/4✓ Branch 0 taken 79080 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 79078 times.
|
158161 | m_key_file_log_index_cache) || |
| 4168 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 79078 times.
|
79080 | DBUG_EVALUATE_IF("fault_injection_openning_index", 1, 0)) { |
| 4169 | /* | ||
| 4170 | TODO: all operations creating/deleting the index file or a log, should | ||
| 4171 | call my_sync_dir() or my_sync_dir_by_file() to be durable. | ||
| 4172 | TODO: file creation should be done with mysql_file_create() | ||
| 4173 | not mysql_file_open(). | ||
| 4174 | */ | ||
| 4175 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
|
3 | if (index_file_nr >= 0) mysql_file_close(index_file_nr, MYF(0)); |
| 4176 | 3 | error = true; | |
| 4177 | 3 | goto end; | |
| 4178 | } | ||
| 4179 | |||
| 4180 | /* | ||
| 4181 | Sync the index by purging any binary log file that is not registered. | ||
| 4182 | In other words, either purge binary log files that were removed from | ||
| 4183 | the index but not purged from the file system due to a crash or purge | ||
| 4184 | any binary log file that was created but not register in the index | ||
| 4185 | due to a crash. | ||
| 4186 | */ | ||
| 4187 | |||
| 4188 | 79078 | if (set_purge_index_file_name(index_file_name_arg) || | |
| 4189 |
1/2✓ Branch 0 taken 79078 times.
✗ Branch 1 not taken.
|
79078 | open_purge_index_file(false) || |
| 4190 |
4/8✓ Branch 0 taken 79078 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 79078 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 79078 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 79078 times.
✗ Branch 7 not taken.
|
237234 | purge_index_entry(nullptr, nullptr, false) || close_purge_index_file() || |
| 4191 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79078 times.
|
79078 | DBUG_EVALUATE_IF("fault_injection_recovering_index", 1, 0)) { |
| 4192 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_SYNC_INDEX_FILE); | |
| 4193 | ✗ | error = true; | |
| 4194 | ✗ | goto end; | |
| 4195 | } | ||
| 4196 | |||
| 4197 | 79078 | end: | |
| 4198 |
2/2✓ Branch 0 taken 21051 times.
✓ Branch 1 taken 58031 times.
|
79082 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 4199 | 79082 | return error; | |
| 4200 | } | ||
| 4201 | |||
| 4202 | /** | ||
| 4203 | Add the GTIDs from the given relaylog file and also | ||
| 4204 | update the IO thread transaction parser. | ||
| 4205 | |||
| 4206 | @param filename Relaylog file to read from. | ||
| 4207 | @param retrieved_gtids Gtid_set to store the GTIDs found on the relaylog file. | ||
| 4208 | @param verify_checksum Set to true to verify event checksums. | ||
| 4209 | @param trx_parser The transaction boundary parser to be used in order to | ||
| 4210 | only add a GTID to the gtid_set after ensuring the transaction is fully | ||
| 4211 | stored on the relay log. | ||
| 4212 | @param partial_trx The trx_monitoring_info of the last incomplete transaction | ||
| 4213 | found in the relay log. | ||
| 4214 | |||
| 4215 | @retval false The file was successfully read and all GTIDs from | ||
| 4216 | Previous_gtids and Gtid_log_event from complete transactions were added to | ||
| 4217 | the retrieved_set. | ||
| 4218 | @retval true There was an error during the procedure. | ||
| 4219 | */ | ||
| 4220 | 9668 | static bool read_gtids_and_update_trx_parser_from_relaylog( | |
| 4221 | const char *filename, Gtid_set *retrieved_gtids, bool verify_checksum, | ||
| 4222 | Transaction_boundary_parser *trx_parser, | ||
| 4223 | Gtid_monitoring_info *partial_trx) { | ||
| 4224 |
1/2✓ Branch 0 taken 9668 times.
✗ Branch 1 not taken.
|
9668 | DBUG_TRACE; |
| 4225 |
3/8✓ Branch 0 taken 9668 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9668 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9668 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
9668 | DBUG_PRINT("info", ("Opening file %s", filename)); |
| 4226 | |||
| 4227 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9668 times.
|
9668 | assert(retrieved_gtids != nullptr); |
| 4228 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9668 times.
|
9668 | assert(trx_parser != nullptr); |
| 4229 | #ifndef NDEBUG | ||
| 4230 | 9668 | unsigned long event_counter = 0; | |
| 4231 | #endif | ||
| 4232 | 9668 | bool error = false; | |
| 4233 | |||
| 4234 |
1/2✓ Branch 0 taken 9668 times.
✗ Branch 1 not taken.
|
9668 | Relaylog_file_reader relaylog_file_reader(verify_checksum); |
| 4235 |
3/4✓ Branch 0 taken 9668 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 9662 times.
|
9668 | if (relaylog_file_reader.open(filename)) { |
| 4236 |
9/18✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 6 times.
✗ Branch 17 not taken.
|
6 | LogErr(ERROR_LEVEL, ER_BINLOG_FILE_OPEN_FAILED, |
| 4237 | relaylog_file_reader.get_error_str()); | ||
| 4238 | |||
| 4239 | /* | ||
| 4240 | As read_gtids_from_binlog() will not throw error on truncated | ||
| 4241 | relaylog files, we should do the same here in order to keep the | ||
| 4242 | current behavior. | ||
| 4243 | */ | ||
| 4244 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (relaylog_file_reader.get_error_type() == |
| 4245 | Binlog_read_error::CANNOT_GET_FILE_PASSWORD) | ||
| 4246 | ✗ | error = true; | |
| 4247 | 6 | return error; | |
| 4248 | } | ||
| 4249 | |||
| 4250 | 9662 | Log_event *ev = nullptr; | |
| 4251 | 9662 | bool seen_prev_gtids = false; | |
| 4252 | 9662 | ulong data_len = 0; | |
| 4253 | |||
| 4254 |
6/8✓ Branch 0 taken 42939 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 42939 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 33277 times.
✓ Branch 5 taken 9662 times.
✓ Branch 6 taken 33277 times.
✓ Branch 7 taken 9662 times.
|
42939 | while (!error && (ev = relaylog_file_reader.read_event_object()) != nullptr) { |
| 4255 |
3/10✓ Branch 0 taken 33277 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33277 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 33277 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
33277 | DBUG_PRINT("info", ("Read event of type %s", ev->get_type_str())); |
| 4256 | #ifndef NDEBUG | ||
| 4257 | 33277 | event_counter++; | |
| 4258 | #endif | ||
| 4259 | |||
| 4260 | 33277 | data_len = uint4korr(ev->temp_buf + EVENT_LEN_OFFSET); | |
| 4261 | |||
| 4262 | 33277 | bool info_error{false}; | |
| 4263 | 33277 | binary_log::Log_event_basic_info log_event_info; | |
| 4264 | 66554 | std::tie(info_error, log_event_info) = extract_log_event_basic_info( | |
| 4265 |
1/2✓ Branch 0 taken 33277 times.
✗ Branch 1 not taken.
|
33277 | ev->temp_buf, data_len, |
| 4266 | 33277 | relaylog_file_reader.format_description_event()); | |
| 4267 | |||
| 4268 |
6/8✓ Branch 0 taken 33277 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33277 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 33274 times.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 33274 times.
|
33277 | if (info_error || trx_parser->feed_event(log_event_info, false)) { |
| 4269 | /* | ||
| 4270 | The transaction boundary parser found an error while parsing a | ||
| 4271 | sequence of events from the relaylog. As we don't know if the | ||
| 4272 | parsing has started from a reliable point (it might started in | ||
| 4273 | a relay log file that begins with the rest of a transaction | ||
| 4274 | that started in a previous relay log file), it is better to do | ||
| 4275 | nothing in this case. The boundary parser will fix itself once | ||
| 4276 | finding an event that represent a transaction boundary. | ||
| 4277 | |||
| 4278 | Suppose the following relaylog: | ||
| 4279 | |||
| 4280 | rl-bin.000011 | rl-bin.000012 | rl-bin.000013 | rl-bin-000014 | ||
| 4281 | ---------------+---------------+---------------+--------------- | ||
| 4282 | PREV_GTIDS | PREV_GTIDS | PREV_GTIDS | PREV_GTIDS | ||
| 4283 | (empty) | (UUID:1-2) | (UUID:1-2) | (UUID:1-2) | ||
| 4284 | ---------------+---------------+---------------+--------------- | ||
| 4285 | XID | QUERY(INSERT) | QUERY(INSERT) | XID | ||
| 4286 | ---------------+---------------+---------------+--------------- | ||
| 4287 | GTID(UUID:2) | | ||
| 4288 | ---------------+ | ||
| 4289 | QUERY(CREATE | | ||
| 4290 | TABLE t1 ...) | | ||
| 4291 | ---------------+ | ||
| 4292 | GTID(UUID:3) | | ||
| 4293 | ---------------+ | ||
| 4294 | QUERY(BEGIN) | | ||
| 4295 | ---------------+ | ||
| 4296 | |||
| 4297 | As it is impossible to determine the current Retrieved_Gtid_Set by only | ||
| 4298 | looking to the PREVIOUS_GTIDS on the last relay log file, and scanning | ||
| 4299 | events on it, we tried to find a relay log file that contains at least | ||
| 4300 | one GTID event during the backwards search. | ||
| 4301 | |||
| 4302 | In the example, we will find a GTID only in rl-bin.000011, as the | ||
| 4303 | UUID:3 transaction was spanned across 4 relay log files. | ||
| 4304 | |||
| 4305 | The transaction spanning can be caused by "FLUSH RELAY LOGS" commands | ||
| 4306 | on slave while it is queuing the transaction. | ||
| 4307 | |||
| 4308 | So, in order to correctly add UUID:3 into Retrieved_Gtid_Set, we need | ||
| 4309 | to parse the relay log starting on the file we found the last GTID | ||
| 4310 | queued to know if the transaction was fully retrieved or not. | ||
| 4311 | |||
| 4312 | Start scanning rl-bin.000011 after resetting the transaction parser | ||
| 4313 | will generate an error, as XID event is only expected inside a DML, | ||
| 4314 | but in this case, we can ignore this error and reset the parser. | ||
| 4315 | */ | ||
| 4316 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | trx_parser->reset(); |
| 4317 | /* | ||
| 4318 | We also have to discard the GTID of the partial transaction that was | ||
| 4319 | not finished if there is one. This is needed supposing that an | ||
| 4320 | incomplete transaction was replicated with a GTID. | ||
| 4321 | |||
| 4322 | GTID(1), QUERY(BEGIN), QUERY(INSERT), ANONYMOUS_GTID, QUERY(DROP ...) | ||
| 4323 | |||
| 4324 | In the example above, without cleaning the partial_trx, | ||
| 4325 | the GTID(1) would be added to the Retrieved_Gtid_Set after the | ||
| 4326 | QUERY(DROP ...) event. | ||
| 4327 | |||
| 4328 | GTID(1), QUERY(BEGIN), QUERY(INSERT), GTID(2), QUERY(DROP ...) | ||
| 4329 | |||
| 4330 | In the example above the GTID(1) will also be discarded as the | ||
| 4331 | GTID(1) transaction is not complete. | ||
| 4332 | */ | ||
| 4333 |
2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
|
3 | if (partial_trx->is_processing_trx_set()) { |
| 4334 | ✗ | DBUG_PRINT("info", | |
| 4335 | ("Discarding Gtid(%d, %" PRId64 ") as the transaction " | ||
| 4336 | "wasn't complete and we found an error in the" | ||
| 4337 | "transaction boundary parser.", | ||
| 4338 | partial_trx->get_processing_trx_gtid()->sidno, | ||
| 4339 | partial_trx->get_processing_trx_gtid()->gno)); | ||
| 4340 | ✗ | partial_trx->clear_processing_trx(); | |
| 4341 | } | ||
| 4342 | } | ||
| 4343 | |||
| 4344 |
4/4✓ Branch 0 taken 11765 times.
✓ Branch 1 taken 9662 times.
✓ Branch 2 taken 1811 times.
✓ Branch 3 taken 10039 times.
|
33277 | switch (ev->get_type_code()) { |
| 4345 | 11765 | case binary_log::FORMAT_DESCRIPTION_EVENT: | |
| 4346 | case binary_log::ROTATE_EVENT: | ||
| 4347 | // do nothing; just accept this event and go to next | ||
| 4348 | 11765 | break; | |
| 4349 | 9662 | case binary_log::PREVIOUS_GTIDS_LOG_EVENT: { | |
| 4350 | 9662 | seen_prev_gtids = true; | |
| 4351 | // add events to sets | ||
| 4352 | 9662 | Previous_gtids_log_event *prev_gtids_ev = | |
| 4353 |
1/2✓ Branch 0 taken 9662 times.
✗ Branch 1 not taken.
|
9662 | (Previous_gtids_log_event *)ev; |
| 4354 |
2/4✓ Branch 0 taken 9662 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9662 times.
|
9662 | if (prev_gtids_ev->add_to_set(retrieved_gtids) != 0) { |
| 4355 | ✗ | error = true; | |
| 4356 | ✗ | break; | |
| 4357 | } | ||
| 4358 | #ifndef NDEBUG | ||
| 4359 |
1/2✓ Branch 0 taken 9662 times.
✗ Branch 1 not taken.
|
9662 | char *prev_buffer = prev_gtids_ev->get_str(nullptr, nullptr); |
| 4360 |
3/8✓ Branch 0 taken 9662 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9662 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9662 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
9662 | DBUG_PRINT("info", ("Got Previous_gtids from file '%s': Gtid_set='%s'.", |
| 4361 | filename, prev_buffer)); | ||
| 4362 |
1/2✓ Branch 0 taken 9662 times.
✗ Branch 1 not taken.
|
9662 | my_free(prev_buffer); |
| 4363 | #endif | ||
| 4364 | 9662 | break; | |
| 4365 | } | ||
| 4366 | 1811 | case binary_log::GTID_LOG_EVENT: { | |
| 4367 | /* If we didn't find any PREVIOUS_GTIDS in this file */ | ||
| 4368 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1811 times.
|
1811 | if (!seen_prev_gtids) { |
| 4369 | ✗ | my_error(ER_BINLOG_LOGICAL_CORRUPTION, MYF(0), filename, | |
| 4370 | "The first global transaction identifier was read, but " | ||
| 4371 | "no other information regarding identifiers existing " | ||
| 4372 | "on the previous log files was found."); | ||
| 4373 | ✗ | error = true; | |
| 4374 | ✗ | break; | |
| 4375 | } | ||
| 4376 | |||
| 4377 |
1/2✓ Branch 0 taken 1811 times.
✗ Branch 1 not taken.
|
1811 | Gtid_log_event *gtid_ev = (Gtid_log_event *)ev; |
| 4378 |
1/2✓ Branch 0 taken 1811 times.
✗ Branch 1 not taken.
|
1811 | rpl_sidno sidno = gtid_ev->get_sidno(retrieved_gtids->get_sid_map()); |
| 4379 | 1811 | ulonglong immediate_commit_timestamp = | |
| 4380 | gtid_ev->immediate_commit_timestamp; | ||
| 4381 | 1811 | longlong original_commit_timestamp = gtid_ev->original_commit_timestamp; | |
| 4382 | |||
| 4383 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1811 times.
|
1811 | if (sidno < 0) { |
| 4384 | ✗ | error = true; | |
| 4385 | ✗ | break; | |
| 4386 | } else { | ||
| 4387 |
2/4✓ Branch 0 taken 1811 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1811 times.
|
1811 | if (retrieved_gtids->ensure_sidno(sidno) != RETURN_STATUS_OK) { |
| 4388 | ✗ | error = true; | |
| 4389 | ✗ | break; | |
| 4390 | } else { | ||
| 4391 | 1811 | Gtid gtid = {sidno, gtid_ev->get_gno()}; | |
| 4392 | /* | ||
| 4393 | As are updating the transaction boundary parser while reading | ||
| 4394 | GTIDs from relay log files to fill the Retrieved_Gtid_Set, we | ||
| 4395 | should not add the GTID here as we don't know if the transaction | ||
| 4396 | is complete on the relay log yet. | ||
| 4397 | */ | ||
| 4398 |
1/2✓ Branch 0 taken 1811 times.
✗ Branch 1 not taken.
|
1811 | partial_trx->start(gtid, original_commit_timestamp, |
| 4399 | immediate_commit_timestamp); | ||
| 4400 | } | ||
| 4401 |
3/8✓ Branch 0 taken 1811 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1811 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1811 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
1811 | DBUG_PRINT( |
| 4402 | "info", | ||
| 4403 | ("Found Gtid in relaylog file '%s': Gtid(%d, %" PRId64 ").", | ||
| 4404 | filename, sidno, gtid_ev->get_gno())); | ||
| 4405 | } | ||
| 4406 | 1811 | break; | |
| 4407 | } | ||
| 4408 | 10039 | case binary_log::ANONYMOUS_GTID_LOG_EVENT: | |
| 4409 | default: | ||
| 4410 | /* | ||
| 4411 | If we reached the end of a transaction after storing it's GTID | ||
| 4412 | in partial_trx structure, it is time to add this GTID to the | ||
| 4413 | retrieved_gtids set because the transaction is complete and there is | ||
| 4414 | no need for asking this transaction again. | ||
| 4415 | */ | ||
| 4416 |
2/2✓ Branch 0 taken 3645 times.
✓ Branch 1 taken 6394 times.
|
10039 | if (trx_parser->is_not_inside_transaction()) { |
| 4417 |
3/4✓ Branch 0 taken 3645 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1809 times.
✓ Branch 3 taken 1836 times.
|
3645 | if (partial_trx->is_processing_trx_set()) { |
| 4418 | const Gtid *fully_retrieved_gtid; | ||
| 4419 |
1/2✓ Branch 0 taken 1809 times.
✗ Branch 1 not taken.
|
1809 | fully_retrieved_gtid = partial_trx->get_processing_trx_gtid(); |
| 4420 |
3/8✓ Branch 0 taken 1809 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1809 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1809 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
1809 | DBUG_PRINT("info", ("Adding Gtid to Retrieved_Gtid_Set as the " |
| 4421 | "transaction was completed at " | ||
| 4422 | "relaylog file '%s': Gtid(%d, %" PRId64 ").", | ||
| 4423 | filename, fully_retrieved_gtid->sidno, | ||
| 4424 | fully_retrieved_gtid->gno)); | ||
| 4425 |
1/2✓ Branch 0 taken 1809 times.
✗ Branch 1 not taken.
|
1809 | retrieved_gtids->_add_gtid(*fully_retrieved_gtid); |
| 4426 | /* | ||
| 4427 | We don't need to update the last queued structure here. We just | ||
| 4428 | want to have the information about the partial transaction left in | ||
| 4429 | the relay log. | ||
| 4430 | */ | ||
| 4431 |
1/2✓ Branch 0 taken 1809 times.
✗ Branch 1 not taken.
|
1809 | partial_trx->clear(); |
| 4432 | } | ||
| 4433 | } | ||
| 4434 | 10039 | break; | |
| 4435 | } | ||
| 4436 |
1/2✓ Branch 0 taken 33277 times.
✗ Branch 1 not taken.
|
33277 | delete ev; |
| 4437 | } | ||
| 4438 | |||
| 4439 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9662 times.
|
9662 | if (relaylog_file_reader.has_fatal_error()) { |
| 4440 | // This is not a fatal error; the log may just be truncated. | ||
| 4441 | // @todo but what other errors could happen? IO error? | ||
| 4442 | ✗ | LogErr(WARNING_LEVEL, ER_BINLOG_ERROR_READING_GTIDS_FROM_RELAY_LOG, -1); | |
| 4443 | ✗ | sql_print_warning(relaylog_file_reader.get_error_str()); | |
| 4444 | } | ||
| 4445 | |||
| 4446 | #ifndef NDEBUG | ||
| 4447 |
8/16✓ Branch 0 taken 9662 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9662 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9662 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9662 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9662 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 9662 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 9662 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 9662 times.
✗ Branch 15 not taken.
|
9662 | LogErr(INFORMATION_LEVEL, ER_BINLOG_EVENTS_READ_FROM_RELAY_LOG_INFO, |
| 4448 | event_counter, filename); | ||
| 4449 | #endif | ||
| 4450 | |||
| 4451 | 9662 | return error; | |
| 4452 | 9668 | } | |
| 4453 | |||
| 4454 | enum enum_read_gtids_from_binlog_status { | ||
| 4455 | GOT_GTIDS, | ||
| 4456 | GOT_PREVIOUS_GTIDS, | ||
| 4457 | NO_GTIDS, | ||
| 4458 | ERROR, | ||
| 4459 | TRUNCATED | ||
| 4460 | }; | ||
| 4461 | /** | ||
| 4462 | Reads GTIDs from the given binlog file. | ||
| 4463 | |||
| 4464 | @param filename File to read from. | ||
| 4465 | @param all_gtids If not NULL, then the GTIDs from the | ||
| 4466 | Previous_gtids_log_event and from all Gtid_log_events are stored in | ||
| 4467 | this object. | ||
| 4468 | @param prev_gtids If not NULL, then the GTIDs from the | ||
| 4469 | Previous_gtids_log_events are stored in this object. | ||
| 4470 | @param first_gtid If not NULL, then the first GTID information from the | ||
| 4471 | file will be stored in this object. | ||
| 4472 | @param sid_map The sid_map object to use in the rpl_sidno generation | ||
| 4473 | of the Gtid_log_event. If lock is needed in the sid_map, the caller | ||
| 4474 | must hold it. | ||
| 4475 | @param verify_checksum Set to true to verify event checksums. | ||
| 4476 | @param is_relay_log Set to true, if filename is a Relay Log, false if it is a | ||
| 4477 | Binary Log. | ||
| 4478 | @retval GOT_GTIDS The file was successfully read and it contains | ||
| 4479 | both Gtid_log_events and Previous_gtids_log_events. | ||
| 4480 | This is only possible if either all_gtids or first_gtid are not null. | ||
| 4481 | @retval GOT_PREVIOUS_GTIDS The file was successfully read and it | ||
| 4482 | contains Previous_gtids_log_events but no Gtid_log_events. | ||
| 4483 | For binary logs, if no all_gtids and no first_gtid are specified, | ||
| 4484 | this function will be done right after reading the PREVIOUS_GTIDS | ||
| 4485 | regardless of the rest of the content of the binary log file. | ||
| 4486 | @retval NO_GTIDS The file was successfully read and it does not | ||
| 4487 | contain GTID events. | ||
| 4488 | @retval ERROR Out of memory, or IO error, or malformed event | ||
| 4489 | structure, or the file is malformed (e.g., contains Gtid_log_events | ||
| 4490 | but no Previous_gtids_log_event). | ||
| 4491 | @retval TRUNCATED The file was truncated before the end of the | ||
| 4492 | first Previous_gtids_log_event. | ||
| 4493 | */ | ||
| 4494 | 20625 | static enum_read_gtids_from_binlog_status read_gtids_from_binlog( | |
| 4495 | const char *filename, Gtid_set *all_gtids, Gtid_set *prev_gtids, | ||
| 4496 | Gtid *first_gtid, Sid_map *sid_map, bool verify_checksum, | ||
| 4497 | bool is_relay_log) { | ||
| 4498 |
1/2✓ Branch 0 taken 20625 times.
✗ Branch 1 not taken.
|
20625 | DBUG_TRACE; |
| 4499 |
3/8✓ Branch 0 taken 20625 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20625 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 20625 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
20625 | DBUG_PRINT("info", ("Opening file %s", filename)); |
| 4500 | |||
| 4501 | #ifndef NDEBUG | ||
| 4502 | 20625 | unsigned long event_counter = 0; | |
| 4503 | /* | ||
| 4504 | We assert here that both all_gtids and prev_gtids, if specified, | ||
| 4505 | uses the same sid_map as the one passed as a parameter. This is just | ||
| 4506 | to ensure that, if the sid_map needed some lock and was locked by | ||
| 4507 | the caller, the lock applies to all the GTID sets this function is | ||
| 4508 | dealing with. | ||
| 4509 | */ | ||
| 4510 |
3/4✓ Branch 0 taken 14497 times.
✓ Branch 1 taken 6128 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 14497 times.
|
20625 | if (all_gtids) assert(all_gtids->get_sid_map() == sid_map); |
| 4511 |
3/4✓ Branch 0 taken 7471 times.
✓ Branch 1 taken 13154 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7471 times.
|
20625 | if (prev_gtids) assert(prev_gtids->get_sid_map() == sid_map); |
| 4512 | #endif | ||
| 4513 | |||
| 4514 |
1/2✓ Branch 0 taken 20625 times.
✗ Branch 1 not taken.
|
20625 | Binlog_file_reader binlog_file_reader(verify_checksum); |
| 4515 |
3/4✓ Branch 0 taken 20625 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 20618 times.
|
20625 | if (binlog_file_reader.open(filename)) { |
| 4516 |
9/18✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 7 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 7 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 7 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 7 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 7 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 7 times.
✗ Branch 17 not taken.
|
7 | LogErr(ERROR_LEVEL, ER_BINLOG_FILE_OPEN_FAILED, |
| 4517 | binlog_file_reader.get_error_str()); | ||
| 4518 | /* | ||
| 4519 | We need to revisit the recovery procedure for relay log | ||
| 4520 | files. Currently, it is called after this routine. | ||
| 4521 | /Alfranio | ||
| 4522 | */ | ||
| 4523 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
|
7 | if (binlog_file_reader.get_error_type() == |
| 4524 | Binlog_read_error::CANNOT_GET_FILE_PASSWORD) | ||
| 4525 | ✗ | return ERROR; | |
| 4526 | 7 | return TRUNCATED; | |
| 4527 | } | ||
| 4528 | |||
| 4529 | 20618 | Log_event *ev = nullptr; | |
| 4530 | 20618 | enum_read_gtids_from_binlog_status ret = NO_GTIDS; | |
| 4531 | 20618 | bool done = false; | |
| 4532 | 20618 | bool seen_first_gtid = false; | |
| 4533 |
7/8✓ Branch 0 taken 8910635 times.
✓ Branch 1 taken 6708 times.
✓ Branch 2 taken 8910635 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8896725 times.
✓ Branch 5 taken 13910 times.
✓ Branch 6 taken 8896725 times.
✓ Branch 7 taken 20618 times.
|
8917343 | while (!done && (ev = binlog_file_reader.read_event_object()) != nullptr) { |
| 4534 | #ifndef NDEBUG | ||
| 4535 | 8896725 | event_counter++; | |
| 4536 | #endif | ||
| 4537 |
3/10✓ Branch 0 taken 8896725 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8896725 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 8896725 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
8896725 | DBUG_PRINT("info", ("Read event of type %s", ev->get_type_str())); |
| 4538 |
5/5✓ Branch 0 taken 22776 times.
✓ Branch 1 taken 20564 times.
✓ Branch 2 taken 6818 times.
✓ Branch 3 taken 853332 times.
✓ Branch 4 taken 7993235 times.
|
8896725 | switch (ev->get_type_code()) { |
| 4539 | 22776 | case binary_log::FORMAT_DESCRIPTION_EVENT: | |
| 4540 | case binary_log::ROTATE_EVENT: | ||
| 4541 | // do nothing; just accept this event and go to next | ||
| 4542 | 22776 | break; | |
| 4543 | 20564 | case binary_log::PREVIOUS_GTIDS_LOG_EVENT: { | |
| 4544 | 20564 | ret = GOT_PREVIOUS_GTIDS; | |
| 4545 | // add events to sets | ||
| 4546 | 20564 | Previous_gtids_log_event *prev_gtids_ev = | |
| 4547 |
1/2✓ Branch 0 taken 20564 times.
✗ Branch 1 not taken.
|
20564 | (Previous_gtids_log_event *)ev; |
| 4548 |
5/8✓ Branch 0 taken 14454 times.
✓ Branch 1 taken 6110 times.
✓ Branch 2 taken 14454 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14454 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 20564 times.
|
20564 | if (all_gtids != nullptr && prev_gtids_ev->add_to_set(all_gtids) != 0) |
| 4549 | ✗ | ret = ERROR, done = true; | |
| 4550 |
3/4✓ Branch 0 taken 7453 times.
✓ Branch 1 taken 13111 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 20564 times.
|
28017 | else if (prev_gtids != nullptr && |
| 4551 |
2/4✓ Branch 0 taken 7453 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7453 times.
|
7453 | prev_gtids_ev->add_to_set(prev_gtids) != 0) |
| 4552 | ✗ | ret = ERROR, done = true; | |
| 4553 | #ifndef NDEBUG | ||
| 4554 |
1/2✓ Branch 0 taken 20564 times.
✗ Branch 1 not taken.
|
20564 | char *prev_buffer = prev_gtids_ev->get_str(nullptr, nullptr); |
| 4555 |
3/8✓ Branch 0 taken 20564 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20564 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 20564 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
20564 | DBUG_PRINT("info", ("Got Previous_gtids from file '%s': Gtid_set='%s'.", |
| 4556 | filename, prev_buffer)); | ||
| 4557 |
1/2✓ Branch 0 taken 20564 times.
✗ Branch 1 not taken.
|
20564 | my_free(prev_buffer); |
| 4558 | #endif | ||
| 4559 | /* | ||
| 4560 | If this is not a relay log, the previous_gtids were asked and no | ||
| 4561 | all_gtids neither first_gtid were asked, it is fine to consider the | ||
| 4562 | job as done. | ||
| 4563 | */ | ||
| 4564 |
8/8✓ Branch 0 taken 10904 times.
✓ Branch 1 taken 9660 times.
✓ Branch 2 taken 7453 times.
✓ Branch 3 taken 3451 times.
✓ Branch 4 taken 6110 times.
✓ Branch 5 taken 1343 times.
✓ Branch 6 taken 3515 times.
✓ Branch 7 taken 2595 times.
|
20564 | if (!is_relay_log && prev_gtids != nullptr && all_gtids == nullptr && |
| 4565 | first_gtid == nullptr) | ||
| 4566 | 3515 | done = true; | |
| 4567 |
2/14✓ Branch 0 taken 20564 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 20564 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
20564 | DBUG_EXECUTE_IF("inject_fault_bug16502579", { |
| 4568 | DBUG_PRINT("debug", ("PREVIOUS_GTIDS_LOG_EVENT found. " | ||
| 4569 | "Injected ret=NO_GTIDS.")); | ||
| 4570 | if (ret == GOT_PREVIOUS_GTIDS) { | ||
| 4571 | ret = NO_GTIDS; | ||
| 4572 | done = false; | ||
| 4573 | } | ||
| 4574 | }); | ||
| 4575 | 20564 | break; | |
| 4576 | } | ||
| 4577 | 6818 | case binary_log::GTID_LOG_EVENT: { | |
| 4578 |
2/2✓ Branch 0 taken 2438 times.
✓ Branch 1 taken 4380 times.
|
6818 | if (ret != GOT_GTIDS) { |
| 4579 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2438 times.
|
2438 | if (ret != GOT_PREVIOUS_GTIDS) { |
| 4580 | /* | ||
| 4581 | Since this routine is run on startup, there may not be a | ||
| 4582 | THD instance. Therefore, ER(X) cannot be used. | ||
| 4583 | */ | ||
| 4584 | const char *msg_fmt = | ||
| 4585 | ✗ | (current_thd != nullptr) | |
| 4586 | ✗ | ? ER_THD(current_thd, ER_BINLOG_LOGICAL_CORRUPTION) | |
| 4587 | ✗ | : ER_DEFAULT(ER_BINLOG_LOGICAL_CORRUPTION); | |
| 4588 | ✗ | my_printf_error( | |
| 4589 | ER_BINLOG_LOGICAL_CORRUPTION, msg_fmt, MYF(0), filename, | ||
| 4590 | "The first global transaction identifier was read, but " | ||
| 4591 | "no other information regarding identifiers existing " | ||
| 4592 | "on the previous log files was found."); | ||
| 4593 | ✗ | ret = ERROR, done = true; | |
| 4594 | ✗ | break; | |
| 4595 | } else | ||
| 4596 | 2438 | ret = GOT_GTIDS; | |
| 4597 | } | ||
| 4598 | /* | ||
| 4599 | When this is a relaylog, we just check if the relay log contains at | ||
| 4600 | least one Gtid_log_event, so that we can distinguish the return values | ||
| 4601 | GOT_GTID and GOT_PREVIOUS_GTIDS. We don't need to read anything else | ||
| 4602 | from the relay log. | ||
| 4603 | When this is a binary log, if all_gtids is requested (i.e., NOT NULL), | ||
| 4604 | we should continue to read all gtids. If just first_gtid was | ||
| 4605 | requested, we will be done after storing this Gtid_log_event info on | ||
| 4606 | it. | ||
| 4607 | */ | ||
| 4608 |
2/2✓ Branch 0 taken 272 times.
✓ Branch 1 taken 6546 times.
|
6818 | if (is_relay_log) { |
| 4609 | 272 | ret = GOT_GTIDS, done = true; | |
| 4610 | } else { | ||
| 4611 |
1/2✓ Branch 0 taken 6546 times.
✗ Branch 1 not taken.
|
6546 | Gtid_log_event *gtid_ev = (Gtid_log_event *)ev; |
| 4612 |
1/2✓ Branch 0 taken 6546 times.
✗ Branch 1 not taken.
|
6546 | rpl_sidno sidno = gtid_ev->get_sidno(sid_map); |
| 4613 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6546 times.
|
6546 | if (sidno < 0) |
| 4614 | ✗ | ret = ERROR, done = true; | |
| 4615 | else { | ||
| 4616 |
2/2✓ Branch 0 taken 4763 times.
✓ Branch 1 taken 1783 times.
|
6546 | if (all_gtids) { |
| 4617 |
2/4✓ Branch 0 taken 4763 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4763 times.
|
4763 | if (all_gtids->ensure_sidno(sidno) != RETURN_STATUS_OK) |
| 4618 | ✗ | ret = ERROR, done = true; | |
| 4619 |
1/2✓ Branch 0 taken 4763 times.
✗ Branch 1 not taken.
|
4763 | all_gtids->_add_gtid(sidno, gtid_ev->get_gno()); |
| 4620 |
3/8✓ Branch 0 taken 4763 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4763 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4763 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
4763 | DBUG_PRINT("info", |
| 4621 | ("Got Gtid from file '%s': Gtid(%d, %" PRId64 ").", | ||
| 4622 | filename, sidno, gtid_ev->get_gno())); | ||
| 4623 | } | ||
| 4624 | |||
| 4625 | /* If the first GTID was requested, stores it */ | ||
| 4626 |
3/4✓ Branch 0 taken 1783 times.
✓ Branch 1 taken 4763 times.
✓ Branch 2 taken 1783 times.
✗ Branch 3 not taken.
|
6546 | if (first_gtid && !seen_first_gtid) { |
| 4627 | 1783 | first_gtid->set(sidno, gtid_ev->get_gno()); | |
| 4628 | 1783 | seen_first_gtid = true; | |
| 4629 | /* If the first_gtid was the only thing requested, we are done */ | ||
| 4630 |
1/2✓ Branch 0 taken 1783 times.
✗ Branch 1 not taken.
|
1783 | if (all_gtids == nullptr) ret = GOT_GTIDS, done = true; |
| 4631 | } | ||
| 4632 | } | ||
| 4633 | } | ||
| 4634 | 6818 | break; | |
| 4635 | } | ||
| 4636 | 853332 | case binary_log::ANONYMOUS_GTID_LOG_EVENT: { | |
| 4637 | /* | ||
| 4638 | When this is a relaylog, we just check if it contains | ||
| 4639 | at least one Anonymous_gtid_log_event after initialization | ||
| 4640 | (FDs, Rotates and PREVIOUS_GTIDS), so that we can distinguish the | ||
| 4641 | return values GOT_GTID and GOT_PREVIOUS_GTIDS. | ||
| 4642 | We don't need to read anything else from the relay log. | ||
| 4643 | */ | ||
| 4644 |
2/2✓ Branch 0 taken 285 times.
✓ Branch 1 taken 853047 times.
|
853332 | if (is_relay_log) { |
| 4645 | 285 | ret = GOT_GTIDS; | |
| 4646 | 285 | done = true; | |
| 4647 | 285 | break; | |
| 4648 | } | ||
| 4649 |
5/6✓ Branch 0 taken 159776 times.
✓ Branch 1 taken 693271 times.
✓ Branch 2 taken 38004 times.
✓ Branch 3 taken 121772 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 38004 times.
|
853047 | assert(prev_gtids == nullptr |
| 4650 | ? true | ||
| 4651 | : all_gtids != nullptr || first_gtid != nullptr); | ||
| 4652 | } | ||
| 4653 | [[fallthrough]]; | ||
| 4654 | default: | ||
| 4655 | // if we found any other event type without finding a | ||
| 4656 | // previous_gtids_log_event, then the rest of this binlog | ||
| 4657 | // cannot contain gtids | ||
| 4658 |
4/4✓ Branch 0 taken 8827652 times.
✓ Branch 1 taken 18630 times.
✓ Branch 2 taken 41 times.
✓ Branch 3 taken 8827611 times.
|
8846282 | if (ret != GOT_GTIDS && ret != GOT_PREVIOUS_GTIDS) done = true; |
| 4659 | /* | ||
| 4660 | The GTIDs of the relaylog files will be handled later | ||
| 4661 | because of the possibility of transactions be spanned | ||
| 4662 | along distinct relaylog files. | ||
| 4663 | So, if we found an ordinary event without finding the | ||
| 4664 | GTID but we already found the PREVIOUS_GTIDS, this probably | ||
| 4665 | means that the event is from a transaction that started on | ||
| 4666 | previous relaylog file. | ||
| 4667 | */ | ||
| 4668 |
4/4✓ Branch 0 taken 8827611 times.
✓ Branch 1 taken 18671 times.
✓ Branch 2 taken 812 times.
✓ Branch 3 taken 8826799 times.
|
8846282 | if (ret == GOT_PREVIOUS_GTIDS && is_relay_log) done = true; |
| 4669 | 8846282 | break; | |
| 4670 | } | ||
| 4671 |
1/2✓ Branch 0 taken 8896725 times.
✗ Branch 1 not taken.
|
8896725 | delete ev; |
| 4672 |
3/8✓ Branch 0 taken 8896725 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8896725 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 8896725 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
8896725 | DBUG_PRINT("info", ("done=%d", done)); |
| 4673 | } | ||
| 4674 | |||
| 4675 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 20606 times.
|
20618 | if (binlog_file_reader.has_fatal_error()) { |
| 4676 | // This is not a fatal error; the log may just be truncated. | ||
| 4677 | |||
| 4678 | // @todo but what other errors could happen? IO error? | ||
| 4679 |
8/16✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 12 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 12 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 12 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 12 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 12 times.
✗ Branch 15 not taken.
|
12 | LogErr(WARNING_LEVEL, ER_BINLOG_ERROR_READING_GTIDS_FROM_BINARY_LOG, -1); |
| 4680 |
2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
|
12 | sql_print_warning(binlog_file_reader.get_error_str()); |
| 4681 | } | ||
| 4682 | |||
| 4683 |
2/2✓ Branch 0 taken 14491 times.
✓ Branch 1 taken 6127 times.
|
20618 | if (all_gtids) |
| 4684 |
1/2✓ Branch 0 taken 14491 times.
✗ Branch 1 not taken.
|
14491 | all_gtids->dbug_print("all_gtids"); |
| 4685 | else | ||
| 4686 |
3/8✓ Branch 0 taken 6127 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6127 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6127 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
6127 | DBUG_PRINT("info", ("all_gtids==NULL")); |
| 4687 |
2/2✓ Branch 0 taken 7470 times.
✓ Branch 1 taken 13148 times.
|
20618 | if (prev_gtids) |
| 4688 |
1/2✓ Branch 0 taken 7470 times.
✗ Branch 1 not taken.
|
7470 | prev_gtids->dbug_print("prev_gtids"); |
| 4689 | else | ||
| 4690 |
3/8✓ Branch 0 taken 13148 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13148 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 13148 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
13148 | DBUG_PRINT("info", ("prev_gtids==NULL")); |
| 4691 |
2/2✓ Branch 0 taken 18008 times.
✓ Branch 1 taken 2610 times.
|
20618 | if (first_gtid == nullptr) |
| 4692 |
3/8✓ Branch 0 taken 18008 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18008 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 18008 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
18008 | DBUG_PRINT("info", ("first_gtid==NULL")); |
| 4693 |
2/2✓ Branch 0 taken 827 times.
✓ Branch 1 taken 1783 times.
|
2610 | else if (first_gtid->sidno == 0) |
| 4694 |
3/8✓ Branch 0 taken 827 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 827 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 827 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
827 | DBUG_PRINT("info", ("first_gtid.sidno==0")); |
| 4695 | else | ||
| 4696 |
1/2✓ Branch 0 taken 1783 times.
✗ Branch 1 not taken.
|
1783 | first_gtid->dbug_print(sid_map, "first_gtid"); |
| 4697 | |||
| 4698 |
3/8✓ Branch 0 taken 20618 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20618 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 20618 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
20618 | DBUG_PRINT("info", ("returning %d", ret)); |
| 4699 | #ifndef NDEBUG | ||
| 4700 |
8/8✓ Branch 0 taken 10956 times.
✓ Branch 1 taken 9662 times.
✓ Branch 2 taken 7470 times.
✓ Branch 3 taken 3486 times.
✓ Branch 4 taken 6127 times.
✓ Branch 5 taken 1343 times.
✓ Branch 6 taken 3517 times.
✓ Branch 7 taken 2610 times.
|
20618 | if (!is_relay_log && prev_gtids != nullptr && all_gtids == nullptr && |
| 4701 | first_gtid == nullptr) | ||
| 4702 |
8/16✓ Branch 0 taken 3517 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3517 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3517 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3517 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3517 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3517 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3517 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3517 times.
✗ Branch 15 not taken.
|
3517 | LogErr(INFORMATION_LEVEL, ER_BINLOG_EVENTS_READ_FROM_BINLOG_INFO, |
| 4703 | event_counter, filename); | ||
| 4704 | #endif | ||
| 4705 | 20618 | return ret; | |
| 4706 | 20625 | } | |
| 4707 | |||
| 4708 | 527 | bool MYSQL_BIN_LOG::find_first_log(std::string &binlog_file_name, | |
| 4709 | std::string &errmsg) { | ||
| 4710 |
1/2✓ Branch 0 taken 527 times.
✗ Branch 1 not taken.
|
527 | auto log_index = this->get_log_index(); |
| 4711 |
1/2✓ Branch 0 taken 527 times.
✗ Branch 1 not taken.
|
527 | std::list<std::string> filename_list = log_index.second; |
| 4712 | |||
| 4713 | 527 | list<string>::iterator fit = filename_list.begin(); | |
| 4714 |
1/2✓ Branch 0 taken 527 times.
✗ Branch 1 not taken.
|
527 | if (fit != filename_list.end()) { |
| 4715 |
1/2✓ Branch 0 taken 527 times.
✗ Branch 1 not taken.
|
527 | binlog_file_name.assign(*fit); |
| 4716 | } else { | ||
| 4717 | ✗ | errmsg.assign("Could not find the first log file name in the index file"); | |
| 4718 | ✗ | return true; | |
| 4719 | } | ||
| 4720 | 527 | return false; | |
| 4721 | 527 | } | |
| 4722 | |||
| 4723 | 2236 | bool MYSQL_BIN_LOG::find_first_log_not_in_gtid_set(char *binlog_file_name, | |
| 4724 | const Gtid_set *gtid_set, | ||
| 4725 | Gtid *first_gtid, | ||
| 4726 | std::string &errmsg) { | ||
| 4727 |
1/2✓ Branch 0 taken 2236 times.
✗ Branch 1 not taken.
|
2236 | DBUG_TRACE; |
| 4728 | 2236 | LOG_INFO linfo; | |
| 4729 |
1/2✓ Branch 0 taken 2236 times.
✗ Branch 1 not taken.
|
2236 | auto log_index = this->get_log_index(); |
| 4730 |
1/2✓ Branch 0 taken 2236 times.
✗ Branch 1 not taken.
|
2236 | std::list<std::string> filename_list = log_index.second; |
| 4731 | 2236 | int error = log_index.first; | |
| 4732 | 2236 | list<string>::reverse_iterator rit; | |
| 4733 |
1/2✓ Branch 0 taken 2236 times.
✗ Branch 1 not taken.
|
2236 | Gtid_set binlog_previous_gtid_set{gtid_set->get_sid_map()}; |
| 4734 | |||
| 4735 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2236 times.
|
2236 | if (error != LOG_INFO_EOF) { |
| 4736 | ✗ | errmsg.assign( | |
| 4737 | "Failed to read the binary log index file while " | ||
| 4738 | "looking for the oldest binary log that contains any GTID " | ||
| 4739 | "that is not in the given gtid set"); | ||
| 4740 | ✗ | error = -1; | |
| 4741 | ✗ | goto end; | |
| 4742 | } | ||
| 4743 | |||
| 4744 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2236 times.
|
2236 | if (filename_list.empty()) { |
| 4745 | ✗ | errmsg.assign( | |
| 4746 | "Could not find first log file name in binary log index file " | ||
| 4747 | "while looking for the oldest binary log that contains any GTID " | ||
| 4748 | "that is not in the given gtid set"); | ||
| 4749 | ✗ | error = -2; | |
| 4750 | ✗ | goto end; | |
| 4751 | } | ||
| 4752 | |||
| 4753 | /* | ||
| 4754 | Iterate over all the binary logs in reverse order, and read only | ||
| 4755 | the Previous_gtids_log_event, to find the first one, that is the | ||
| 4756 | subset of the given gtid set. Since every binary log begins with | ||
| 4757 | a Previous_gtids_log_event, that contains all GTIDs in all | ||
| 4758 | previous binary logs. | ||
| 4759 | We also ask for the first GTID in the binary log to know if we | ||
| 4760 | should send the FD event with the "created" field cleared or not. | ||
| 4761 | */ | ||
| 4762 |
3/8✓ Branch 0 taken 2236 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2236 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2236 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
2236 | DBUG_PRINT("info", ("Iterating backwards through binary logs, and reading " |
| 4763 | "only the Previous_gtids_log_event, to find the first " | ||
| 4764 | "one, that is the subset of the given gtid set.")); | ||
| 4765 | 2236 | rit = filename_list.rbegin(); | |
| 4766 | 2236 | error = 0; | |
| 4767 |
3/4✓ Branch 0 taken 2259 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2258 times.
✓ Branch 3 taken 1 times.
|
2259 | while (rit != filename_list.rend()) { |
| 4768 |
1/2✓ Branch 0 taken 2258 times.
✗ Branch 1 not taken.
|
2258 | binlog_previous_gtid_set.clear(); |
| 4769 |
1/2✓ Branch 0 taken 2258 times.
✗ Branch 1 not taken.
|
2258 | const char *filename = rit->c_str(); |
| 4770 |
3/8✓ Branch 0 taken 2258 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2258 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2258 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
2258 | DBUG_PRINT("info", |
| 4771 | ("Read Previous_gtids_log_event from filename='%s'", filename)); | ||
| 4772 |
3/7✓ Branch 0 taken 2258 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 2257 times.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.
|
2258 | switch (read_gtids_from_binlog(filename, nullptr, &binlog_previous_gtid_set, |
| 4773 | first_gtid, | ||
| 4774 | binlog_previous_gtid_set.get_sid_map(), | ||
| 4775 | 2258 | opt_source_verify_checksum, is_relay_log)) { | |
| 4776 | ✗ | case ERROR: | |
| 4777 | ✗ | errmsg.assign( | |
| 4778 | "Error reading header of binary log while looking for " | ||
| 4779 | "the oldest binary log that contains any GTID that is not in " | ||
| 4780 | "the given gtid set"); | ||
| 4781 | ✗ | error = -3; | |
| 4782 | ✗ | goto end; | |
| 4783 | ✗ | case NO_GTIDS: | |
| 4784 | ✗ | errmsg.assign( | |
| 4785 | "Found old binary log without GTIDs while looking for " | ||
| 4786 | "the oldest binary log that contains any GTID that is not in " | ||
| 4787 | "the given gtid set"); | ||
| 4788 | ✗ | error = -4; | |
| 4789 | ✗ | goto end; | |
| 4790 | 2257 | case GOT_GTIDS: | |
| 4791 | case GOT_PREVIOUS_GTIDS: | ||
| 4792 |
3/4✓ Branch 0 taken 2257 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2235 times.
✓ Branch 3 taken 22 times.
|
2257 | if (binlog_previous_gtid_set.is_subset(gtid_set)) { |
| 4793 | 2235 | strcpy(binlog_file_name, filename); | |
| 4794 | /* | ||
| 4795 | Verify that the selected binlog is not the first binlog, | ||
| 4796 | */ | ||
| 4797 |
2/6✓ Branch 0 taken 2235 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2235 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
2235 | DBUG_EXECUTE_IF("replica_reconnect_with_gtid_set_executed", |
| 4798 | assert(strcmp(filename_list.begin()->c_str(), | ||
| 4799 | binlog_file_name) != 0);); | ||
| 4800 | 2235 | goto end; | |
| 4801 | } | ||
| 4802 | case TRUNCATED: | ||
| 4803 | 23 | break; | |
| 4804 | } | ||
| 4805 | |||
| 4806 |
1/2✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
|
23 | rit++; |
| 4807 | } | ||
| 4808 | |||
| 4809 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
|
1 | if (rit == filename_list.rend()) { |
| 4810 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | report_missing_gtids(&binlog_previous_gtid_set, gtid_set, errmsg); |
| 4811 | 1 | error = -5; | |
| 4812 | } | ||
| 4813 | |||
| 4814 | ✗ | end: | |
| 4815 |
5/10✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2235 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
2236 | if (error) DBUG_PRINT("error", ("'%s'", errmsg.c_str())); |
| 4816 | 2236 | filename_list.clear(); | |
| 4817 |
3/8✓ Branch 0 taken 2236 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2236 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2236 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
2236 | DBUG_PRINT("info", ("returning %d", error)); |
| 4818 | 2236 | return error != 0 ? true : false; | |
| 4819 | 2236 | } | |
| 4820 | |||
| 4821 | 10418 | bool MYSQL_BIN_LOG::init_gtid_sets(Gtid_set *all_gtids, Gtid_set *lost_gtids, | |
| 4822 | bool verify_checksum, bool need_lock, | ||
| 4823 | Transaction_boundary_parser *trx_parser, | ||
| 4824 | Gtid_monitoring_info *partial_trx, | ||
| 4825 | bool is_server_starting) { | ||
| 4826 |
1/2✓ Branch 0 taken 10418 times.
✗ Branch 1 not taken.
|
10418 | DBUG_TRACE; |
| 4827 |
3/10✓ Branch 0 taken 10418 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10418 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 10418 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
10418 | DBUG_PRINT( |
| 4828 | "info", | ||
| 4829 | ("lost_gtids=%p; so we are recovering a %s log; is_relay_log=%d", | ||
| 4830 | lost_gtids, lost_gtids == nullptr ? "relay" : "binary", is_relay_log)); | ||
| 4831 | |||
| 4832 | Checkable_rwlock *sid_lock = | ||
| 4833 |
2/2✓ Branch 0 taken 1225 times.
✓ Branch 1 taken 9193 times.
|
10418 | is_relay_log ? all_gtids->get_sid_map()->get_sid_lock() : global_sid_lock; |
| 4834 | /* | ||
| 4835 | If this is a relay log, we must have the IO thread Master_info trx_parser | ||
| 4836 | in order to correctly feed it with relay log events. | ||
| 4837 | */ | ||
| 4838 | #ifndef NDEBUG | ||
| 4839 |
2/2✓ Branch 0 taken 1225 times.
✓ Branch 1 taken 9193 times.
|
10418 | if (is_relay_log) { |
| 4840 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1225 times.
|
1225 | assert(trx_parser != nullptr); |
| 4841 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1225 times.
|
1225 | assert(lost_gtids == nullptr); |
| 4842 | } | ||
| 4843 | #endif | ||
| 4844 | |||
| 4845 | /* | ||
| 4846 | Acquires the necessary locks to ensure that logs are not either | ||
| 4847 | removed or updated when we are reading from it. | ||
| 4848 | */ | ||
| 4849 |
2/2✓ Branch 0 taken 10211 times.
✓ Branch 1 taken 207 times.
|
10418 | if (need_lock) { |
| 4850 | // We don't need LOCK_log if we are only going to read the initial | ||
| 4851 | // Prevoius_gtids_log_event and ignore the Gtid_log_events. | ||
| 4852 |
2/4✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10211 times.
✗ Branch 3 not taken.
|
10211 | if (all_gtids != nullptr) mysql_mutex_lock(&LOCK_log); |
| 4853 |
1/2✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
|
10211 | mysql_mutex_lock(&LOCK_index); |
| 4854 |
1/2✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
|
10211 | sid_lock->wrlock(); |
| 4855 | } else { | ||
| 4856 | if (all_gtids != nullptr) mysql_mutex_assert_owner(&LOCK_log); | ||
| 4857 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 4858 |
1/2✓ Branch 0 taken 207 times.
✗ Branch 1 not taken.
|
207 | sid_lock->assert_some_wrlock(); |
| 4859 | } | ||
| 4860 | |||
| 4861 | /* Initialize the sid_map to be used in read_gtids_from_binlog */ | ||
| 4862 | 10418 | Sid_map *sid_map = nullptr; | |
| 4863 |
2/2✓ Branch 0 taken 10211 times.
✓ Branch 1 taken 207 times.
|
10418 | if (all_gtids) |
| 4864 | 10211 | sid_map = all_gtids->get_sid_map(); | |
| 4865 |
1/2✓ Branch 0 taken 207 times.
✗ Branch 1 not taken.
|
207 | else if (lost_gtids) |
| 4866 | 207 | sid_map = lost_gtids->get_sid_map(); | |
| 4867 | |||
| 4868 | // Gather the set of files to be accessed. | ||
| 4869 |
1/2✓ Branch 0 taken 10418 times.
✗ Branch 1 not taken.
|
10418 | auto log_index = this->get_log_index(false); |
| 4870 |
1/2✓ Branch 0 taken 10418 times.
✗ Branch 1 not taken.
|
10418 | std::list<std::string> filename_list = log_index.second; |
| 4871 | 10418 | int error = log_index.first; | |
| 4872 | 10418 | list<string>::iterator it; | |
| 4873 | 10418 | list<string>::reverse_iterator rit; | |
| 4874 | 10418 | bool reached_first_file = false; | |
| 4875 | |||
| 4876 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10418 times.
|
10418 | if (error != LOG_INFO_EOF) { |
| 4877 | ✗ | DBUG_PRINT("error", ("Error reading %s index", | |
| 4878 | is_relay_log ? "relaylog" : "binlog")); | ||
| 4879 | ✗ | goto end; | |
| 4880 | } | ||
| 4881 | /* | ||
| 4882 | On server starting, one new empty binlog file is created and | ||
| 4883 | its file name is put into index file before initializing | ||
| 4884 | GLOBAL.GTID_EXECUTED AND GLOBAL.GTID_PURGED, it is not the | ||
| 4885 | last binlog file before the server restarts, so we remove | ||
| 4886 | its file name from filename_list. | ||
| 4887 | */ | ||
| 4888 |
6/8✓ Branch 0 taken 8986 times.
✓ Branch 1 taken 1432 times.
✓ Branch 2 taken 8986 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8986 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 8986 times.
✓ Branch 7 taken 1432 times.
|
10418 | if (is_server_starting && !is_relay_log && !filename_list.empty()) |
| 4889 | 8986 | filename_list.pop_back(); | |
| 4890 | |||
| 4891 | 10418 | error = 0; | |
| 4892 |
2/2✓ Branch 0 taken 10211 times.
✓ Branch 1 taken 207 times.
|
10418 | if (all_gtids != nullptr) { |
| 4893 |
3/12✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10211 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 10211 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
10211 | DBUG_PRINT("info", ("Iterating backwards through %s logs, " |
| 4894 | "looking for the last %s log that contains " | ||
| 4895 | "a Previous_gtids_log_event.", | ||
| 4896 | is_relay_log ? "relay" : "binary", | ||
| 4897 | is_relay_log ? "relay" : "binary")); | ||
| 4898 | // Iterate over all files in reverse order until we find one that | ||
| 4899 | // contains a Previous_gtids_log_event. | ||
| 4900 | 10211 | rit = filename_list.rbegin(); | |
| 4901 | 10211 | bool can_stop_reading = false; | |
| 4902 |
1/2✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
|
10211 | reached_first_file = (rit == filename_list.rend()); |
| 4903 |
3/12✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10211 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 10211 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
10211 | DBUG_PRINT("info", |
| 4904 | ("filename='%s' reached_first_file=%d", | ||
| 4905 | reached_first_file ? "" : rit->c_str(), reached_first_file)); | ||
| 4906 |
4/4✓ Branch 0 taken 19352 times.
✓ Branch 1 taken 5351 times.
✓ Branch 2 taken 14497 times.
✓ Branch 3 taken 4855 times.
|
24703 | while (!can_stop_reading && !reached_first_file) { |
| 4907 |
1/2✓ Branch 0 taken 14497 times.
✗ Branch 1 not taken.
|
14497 | const char *filename = rit->c_str(); |
| 4908 |
2/4✓ Branch 0 taken 14497 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14497 times.
|
14497 | assert(rit != filename_list.rend()); |
| 4909 |
1/2✓ Branch 0 taken 14497 times.
✗ Branch 1 not taken.
|
14497 | rit++; |
| 4910 |
1/2✓ Branch 0 taken 14497 times.
✗ Branch 1 not taken.
|
14497 | reached_first_file = (rit == filename_list.rend()); |
| 4911 |
3/8✓ Branch 0 taken 14497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14497 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14497 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
14497 | DBUG_PRINT("info", ("filename='%s' can_stop_reading=%d " |
| 4912 | "reached_first_file=%d, ", | ||
| 4913 | filename, can_stop_reading, reached_first_file)); | ||
| 4914 |
5/8✓ Branch 0 taken 14497 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 940 times.
✓ Branch 4 taken 13514 times.
✓ Branch 5 taken 37 times.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
|
14497 | switch (read_gtids_from_binlog( |
| 4915 | filename, all_gtids, reached_first_file ? lost_gtids : nullptr, | ||
| 4916 |
2/2✓ Branch 0 taken 2009 times.
✓ Branch 1 taken 12488 times.
|
14497 | nullptr /* first_gtid */, sid_map, verify_checksum, is_relay_log)) { |
| 4917 | ✗ | case ERROR: { | |
| 4918 | ✗ | error = 1; | |
| 4919 | ✗ | goto end; | |
| 4920 | } | ||
| 4921 | 940 | case GOT_GTIDS: { | |
| 4922 | 940 | can_stop_reading = true; | |
| 4923 | 940 | break; | |
| 4924 | } | ||
| 4925 | 13514 | case GOT_PREVIOUS_GTIDS: { | |
| 4926 | /* | ||
| 4927 | If this is a binlog file, it is enough to have GOT_PREVIOUS_GTIDS. | ||
| 4928 | If this is a relaylog file, we need to find at least one GTID to | ||
| 4929 | start parsing the relay log to add GTID of transactions that might | ||
| 4930 | have spanned in distinct relaylog files. | ||
| 4931 | */ | ||
| 4932 |
2/2✓ Branch 0 taken 4411 times.
✓ Branch 1 taken 9103 times.
|
13514 | if (!is_relay_log) can_stop_reading = true; |
| 4933 | 13514 | break; | |
| 4934 | } | ||
| 4935 | 37 | case NO_GTIDS: { | |
| 4936 | /* | ||
| 4937 | Mysql server iterates backwards through binary logs, looking for | ||
| 4938 | the last binary log that contains a Previous_gtids_log_event for | ||
| 4939 | gathering the set of gtid_executed on server start. This may take | ||
| 4940 | very long time if it has many binary logs and almost all of them | ||
| 4941 | are out of filesystem cache. So if the binlog_gtid_simple_recovery | ||
| 4942 | is enabled, and the last binary log does not contain any GTID | ||
| 4943 | event, do not read any more binary logs, GLOBAL.GTID_EXECUTED and | ||
| 4944 | GLOBAL.GTID_PURGED should be empty in the case. | ||
| 4945 | */ | ||
| 4946 |
4/4✓ Branch 0 taken 7 times.
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 2 times.
|
37 | if (binlog_gtid_simple_recovery && is_server_starting && |
| 4947 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | !is_relay_log) { |
| 4948 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
|
5 | assert(all_gtids->is_empty()); |
| 4949 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
|
5 | assert(lost_gtids->is_empty()); |
| 4950 | 5 | goto end; | |
| 4951 | } | ||
| 4952 | [[fallthrough]]; | ||
| 4953 | } | ||
| 4954 | case TRUNCATED: { | ||
| 4955 | 38 | break; | |
| 4956 | } | ||
| 4957 | } | ||
| 4958 | } | ||
| 4959 | |||
| 4960 | /* | ||
| 4961 | If we use GTIDs and have partial transactions on the relay log, | ||
| 4962 | must check if it ends on next relay log files. | ||
| 4963 | We also need to feed the boundary parser with the rest of the | ||
| 4964 | relay log to put it in the correct state before receiving new | ||
| 4965 | events from the master in the case of GTID auto positioning be | ||
| 4966 | disabled. | ||
| 4967 | */ | ||
| 4968 |
6/6✓ Branch 0 taken 1225 times.
✓ Branch 1 taken 8981 times.
✓ Branch 2 taken 1205 times.
✓ Branch 3 taken 20 times.
✓ Branch 4 taken 1205 times.
✓ Branch 5 taken 9001 times.
|
10206 | if (is_relay_log && filename_list.size() > 0) { |
| 4969 | /* | ||
| 4970 | Suppose the following relaylog: | ||
| 4971 | |||
| 4972 | rl-bin.000001 | rl-bin.000002 | rl-bin.000003 | rl-bin-000004 | ||
| 4973 | ---------------+---------------+---------------+--------------- | ||
| 4974 | PREV_GTIDS | PREV_GTIDS | PREV_GTIDS | PREV_GTIDS | ||
| 4975 | (empty) | (UUID:1) | (UUID:1) | (UUID:1) | ||
| 4976 | ---------------+---------------+---------------+--------------- | ||
| 4977 | GTID(UUID:1) | QUERY(INSERT) | QUERY(INSERT) | XID | ||
| 4978 | ---------------+---------------+---------------+--------------- | ||
| 4979 | QUERY(CREATE | | ||
| 4980 | TABLE t1 ...) | | ||
| 4981 | ---------------+ | ||
| 4982 | GTID(UUID:2) | | ||
| 4983 | ---------------+ | ||
| 4984 | QUERY(BEGIN) | | ||
| 4985 | ---------------+ | ||
| 4986 | |||
| 4987 | As it is impossible to determine the current Retrieved_Gtid_Set by only | ||
| 4988 | looking to the PREVIOUS_GTIDS on the last relay log file, and scanning | ||
| 4989 | events on it, we tried to find a relay log file that contains at least | ||
| 4990 | one GTID event during the backwards search. | ||
| 4991 | |||
| 4992 | In the example, we will find a GTID only in rl-bin.000001, as the | ||
| 4993 | UUID:2 transaction was spanned across 4 relay log files. | ||
| 4994 | |||
| 4995 | The transaction spanning can be caused by "FLUSH RELAY LOGS" commands | ||
| 4996 | on slave while it is queuing the transaction. | ||
| 4997 | |||
| 4998 | So, in order to correctly add UUID:2 into Retrieved_Gtid_Set, we need | ||
| 4999 | to parse the relay log starting on the file we found the last GTID | ||
| 5000 | queued to know if the transaction was fully retrieved or not. | ||
| 5001 | */ | ||
| 5002 | |||
| 5003 | /* | ||
| 5004 | Adjust the reverse iterator to point to the relaylog file we | ||
| 5005 | need to start parsing, as it was incremented after generating | ||
| 5006 | the relay log file name. | ||
| 5007 | */ | ||
| 5008 |
2/4✓ Branch 0 taken 1205 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1205 times.
|
1205 | assert(rit != filename_list.rbegin()); |
| 5009 |
1/2✓ Branch 0 taken 1205 times.
✗ Branch 1 not taken.
|
1205 | rit--; |
| 5010 |
2/4✓ Branch 0 taken 1205 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1205 times.
|
1205 | assert(rit != filename_list.rend()); |
| 5011 | /* Reset the transaction parser before feeding it with events */ | ||
| 5012 |
1/2✓ Branch 0 taken 1205 times.
✗ Branch 1 not taken.
|
1205 | trx_parser->reset(); |
| 5013 |
1/2✓ Branch 0 taken 1205 times.
✗ Branch 1 not taken.
|
1205 | partial_trx->clear(); |
| 5014 | |||
| 5015 |
3/8✓ Branch 0 taken 1205 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1205 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1205 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
1205 | DBUG_PRINT("info", ("Iterating forwards through relay logs, " |
| 5016 | "updating the Retrieved_Gtid_Set and updating " | ||
| 5017 | "IO thread trx parser before start.")); | ||
| 5018 |
1/2✓ Branch 0 taken 1205 times.
✗ Branch 1 not taken.
|
1205 | for (it = find(filename_list.begin(), filename_list.end(), *rit); |
| 5019 |
2/2✓ Branch 0 taken 9668 times.
✓ Branch 1 taken 1205 times.
|
10873 | it != filename_list.end(); it++) { |
| 5020 | 9668 | const char *filename = it->c_str(); | |
| 5021 |
3/8✓ Branch 0 taken 9668 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9668 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9668 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
9668 | DBUG_PRINT("info", ("filename='%s'", filename)); |
| 5022 |
2/4✓ Branch 0 taken 9668 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9668 times.
|
9668 | if (read_gtids_and_update_trx_parser_from_relaylog( |
| 5023 | filename, all_gtids, true, trx_parser, partial_trx)) { | ||
| 5024 | ✗ | error = 1; | |
| 5025 | ✗ | goto end; | |
| 5026 | } | ||
| 5027 | } | ||
| 5028 | } | ||
| 5029 | } | ||
| 5030 |
4/4✓ Branch 0 taken 1225 times.
✓ Branch 1 taken 9188 times.
✓ Branch 2 taken 5530 times.
✓ Branch 3 taken 3658 times.
|
10413 | if (lost_gtids != nullptr && !reached_first_file) { |
| 5031 | /* | ||
| 5032 | This branch is only reachable by a binary log. The relay log | ||
| 5033 | don't need to get lost_gtids information. | ||
| 5034 | |||
| 5035 | A 5.6 server sets GTID_PURGED by rotating the binary log. | ||
| 5036 | |||
| 5037 | A 5.6 server that had recently enabled GTIDs and set GTID_PURGED | ||
| 5038 | would have a sequence of binary logs like: | ||
| 5039 | |||
| 5040 | master-bin.N : No PREVIOUS_GTIDS (GTID wasn't enabled) | ||
| 5041 | master-bin.N+1: Has an empty PREVIOUS_GTIDS and a ROTATE | ||
| 5042 | (GTID was enabled on startup) | ||
| 5043 | master-bin.N+2: Has a PREVIOUS_GTIDS with the content set by a | ||
| 5044 | SET @@GLOBAL.GTID_PURGED + has GTIDs of some | ||
| 5045 | transactions. | ||
| 5046 | |||
| 5047 | If this 5.6 server be upgraded to 5.7 keeping its binary log files, | ||
| 5048 | this routine will have to find the first binary log that contains a | ||
| 5049 | PREVIOUS_GTIDS + a GTID event to ensure that the content of the | ||
| 5050 | GTID_PURGED will be correctly set (assuming binlog_gtid_simple_recovery | ||
| 5051 | is not enabled). | ||
| 5052 | */ | ||
| 5053 |
3/8✓ Branch 0 taken 3658 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3658 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3658 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
3658 | DBUG_PRINT("info", ("Iterating forwards through binary logs, looking for " |
| 5054 | "the first binary log that contains both a " | ||
| 5055 | "Previous_gtids_log_event and a Gtid_log_event.")); | ||
| 5056 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3658 times.
|
3658 | assert(!is_relay_log); |
| 5057 |
2/2✓ Branch 0 taken 3870 times.
✓ Branch 1 taken 15 times.
|
3885 | for (it = filename_list.begin(); it != filename_list.end(); it++) { |
| 5058 | /* | ||
| 5059 | We should pass a first_gtid to read_gtids_from_binlog when | ||
| 5060 | binlog_gtid_simple_recovery is disabled, or else it will return | ||
| 5061 | right after reading the PREVIOUS_GTIDS event to avoid stall on | ||
| 5062 | reading the whole binary log. | ||
| 5063 | */ | ||
| 5064 | 3870 | Gtid first_gtid = {0, 0}; | |
| 5065 | 3870 | const char *filename = it->c_str(); | |
| 5066 |
3/8✓ Branch 0 taken 3870 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3870 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3870 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
3870 | DBUG_PRINT("info", ("filename='%s'", filename)); |
| 5067 |
3/7✓ Branch 0 taken 3870 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 126 times.
✓ Branch 4 taken 3744 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
|
3870 | switch (read_gtids_from_binlog( |
| 5068 | filename, nullptr, lost_gtids, | ||
| 5069 | binlog_gtid_simple_recovery ? nullptr : &first_gtid, sid_map, | ||
| 5070 |
2/2✓ Branch 0 taken 3517 times.
✓ Branch 1 taken 353 times.
|
3870 | verify_checksum, is_relay_log)) { |
| 5071 | ✗ | case ERROR: { | |
| 5072 | ✗ | error = 1; | |
| 5073 | [[fallthrough]]; | ||
| 5074 | } | ||
| 5075 | 126 | case GOT_GTIDS: { | |
| 5076 | 3643 | goto end; | |
| 5077 | } | ||
| 5078 | 3744 | case NO_GTIDS: | |
| 5079 | case GOT_PREVIOUS_GTIDS: { | ||
| 5080 | /* | ||
| 5081 | Mysql server iterates forwards through binary logs, looking for | ||
| 5082 | the first binary log that contains both Previous_gtids_log_event | ||
| 5083 | and gtid_log_event for gathering the set of gtid_purged on server | ||
| 5084 | start. It also iterates forwards through binary logs, looking for | ||
| 5085 | the first binary log that contains both Previous_gtids_log_event | ||
| 5086 | and gtid_log_event for gathering the set of gtid_purged when | ||
| 5087 | purging binary logs. This may take very long time if it has many | ||
| 5088 | binary logs and almost all of them are out of filesystem cache. | ||
| 5089 | So if the binlog_gtid_simple_recovery is enabled, we just | ||
| 5090 | initialize GLOBAL.GTID_PURGED from the first binary log, do not | ||
| 5091 | read any more binary logs. | ||
| 5092 | */ | ||
| 5093 |
2/2✓ Branch 0 taken 3517 times.
✓ Branch 1 taken 227 times.
|
3744 | if (binlog_gtid_simple_recovery) goto end; |
| 5094 | [[fallthrough]]; | ||
| 5095 | } | ||
| 5096 | case TRUNCATED: { | ||
| 5097 | 227 | break; | |
| 5098 | } | ||
| 5099 | } | ||
| 5100 | } | ||
| 5101 | } | ||
| 5102 | 6755 | end: | |
| 5103 |
3/4✓ Branch 0 taken 10211 times.
✓ Branch 1 taken 207 times.
✓ Branch 2 taken 10211 times.
✗ Branch 3 not taken.
|
10418 | if (all_gtids) all_gtids->dbug_print("all_gtids"); |
| 5104 |
3/4✓ Branch 0 taken 9193 times.
✓ Branch 1 taken 1225 times.
✓ Branch 2 taken 9193 times.
✗ Branch 3 not taken.
|
10418 | if (lost_gtids) lost_gtids->dbug_print("lost_gtids"); |
| 5105 |
2/2✓ Branch 0 taken 10211 times.
✓ Branch 1 taken 207 times.
|
10418 | if (need_lock) { |
| 5106 |
1/2✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
|
10211 | sid_lock->unlock(); |
| 5107 |
1/2✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
|
10211 | mysql_mutex_unlock(&LOCK_index); |
| 5108 |
2/4✓ Branch 0 taken 10211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10211 times.
✗ Branch 3 not taken.
|
10211 | if (all_gtids != nullptr) mysql_mutex_unlock(&LOCK_log); |
| 5109 | } | ||
| 5110 | 10418 | filename_list.clear(); | |
| 5111 |
3/8✓ Branch 0 taken 10418 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10418 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 10418 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
10418 | DBUG_PRINT("info", ("returning %d", error)); |
| 5112 | 10418 | return error != 0 ? true : false; | |
| 5113 | 10418 | } | |
| 5114 | |||
| 5115 | /** | ||
| 5116 | Open a (new) binlog file. | ||
| 5117 | |||
| 5118 | - Open the log file and the index file. Register the new | ||
| 5119 | file name in it | ||
| 5120 | - When calling this when the file is in use, you must have a locks | ||
| 5121 | on LOCK_log and LOCK_index. | ||
| 5122 | |||
| 5123 | @retval | ||
| 5124 | 0 ok | ||
| 5125 | @retval | ||
| 5126 | 1 error | ||
| 5127 | */ | ||
| 5128 | |||
| 5129 | 78866 | bool MYSQL_BIN_LOG::open_binlog( | |
| 5130 | const char *log_name, const char *new_name, ulong max_size_arg, | ||
| 5131 | bool null_created_arg, bool need_lock_index, bool need_sid_lock, | ||
| 5132 | Format_description_log_event *extra_description_event, | ||
| 5133 | uint32 new_index_number) { | ||
| 5134 | // lock_index must be acquired *before* sid_lock. | ||
| 5135 |
3/4✓ Branch 0 taken 26265 times.
✓ Branch 1 taken 52601 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 26265 times.
|
78866 | assert(need_sid_lock || !need_lock_index); |
| 5136 |
1/2✓ Branch 0 taken 78866 times.
✗ Branch 1 not taken.
|
78866 | DBUG_TRACE; |
| 5137 |
3/8✓ Branch 0 taken 78866 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78866 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 78866 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
78866 | DBUG_PRINT("enter", ("base filename: %s", log_name)); |
| 5138 | |||
| 5139 | mysql_mutex_assert_owner(get_log_lock()); | ||
| 5140 | |||
| 5141 |
3/4✓ Branch 0 taken 78866 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 78863 times.
|
78866 | if (init_and_set_log_file_name(log_name, new_name, new_index_number)) { |
| 5142 |
8/16✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
|
3 | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_GENERATE_NEW_FILE_NAME); |
| 5143 | 3 | return true; | |
| 5144 | } | ||
| 5145 | |||
| 5146 |
3/8✓ Branch 0 taken 78863 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78863 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 78863 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
78863 | DBUG_PRINT("info", ("generated filename: %s", log_file_name)); |
| 5147 | |||
| 5148 |
1/2✓ Branch 0 taken 78863 times.
✗ Branch 1 not taken.
|
78863 | if (open_purge_index_file(true) || |
| 5149 |
8/12✓ Branch 0 taken 78863 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78863 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 78863 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 78863 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 78862 times.
✓ Branch 9 taken 1 times.
✓ Branch 10 taken 3 times.
✓ Branch 11 taken 78860 times.
|
157725 | register_create_index_entry(log_file_name) || sync_purge_index_file() || |
| 5150 |
3/4✓ Branch 0 taken 78862 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 78860 times.
|
78862 | DBUG_EVALUATE_IF("fault_injection_registering_index", 1, 0)) { |
| 5151 | /** | ||
| 5152 | @todo: although this was introduced to appease valgrind | ||
| 5153 | when injecting emulated faults using fault_injection_registering_index | ||
| 5154 | it may be good to consider what actually happens when | ||
| 5155 | open_purge_index_file succeeds but register or sync fails. | ||
| 5156 | |||
| 5157 | Perhaps we might need the code below in MYSQL_BIN_LOG::cleanup | ||
| 5158 | for "real life" purposes as well? | ||
| 5159 | */ | ||
| 5160 |
6/10✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
|
3 | DBUG_EXECUTE_IF("fault_injection_registering_index", { |
| 5161 | if (my_b_inited(&purge_index_file)) { | ||
| 5162 | end_io_cache(&purge_index_file); | ||
| 5163 | my_close(purge_index_file.file, MYF(0)); | ||
| 5164 | } | ||
| 5165 | }); | ||
| 5166 | |||
| 5167 |
8/16✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
|
3 | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_SYNC_INDEX_FILE_IN_OPEN); |
| 5168 | 3 | return true; | |
| 5169 | } | ||
| 5170 |
2/6✓ Branch 0 taken 78860 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78860 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
78860 | DBUG_EXECUTE_IF("crash_create_non_critical_before_update_index", |
| 5171 | DBUG_SUICIDE();); | ||
| 5172 | |||
| 5173 | 78860 | write_error = false; | |
| 5174 | |||
| 5175 | /* open the main log file */ | ||
| 5176 |
3/4✓ Branch 0 taken 78859 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 78858 times.
|
78860 | if (open(m_key_file_log, log_name, new_name, new_index_number)) { |
| 5177 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | close_purge_index_file(); |
| 5178 | 1 | return true; /* all warnings issued */ | |
| 5179 | } | ||
| 5180 | |||
| 5181 | 78858 | max_size = max_size_arg; | |
| 5182 | |||
| 5183 | 78858 | bool write_file_name_to_index_file = false; | |
| 5184 | |||
| 5185 | /* This must be before goto err. */ | ||
| 5186 | #ifndef NDEBUG | ||
| 5187 | 78858 | binary_log_debug::debug_pretend_version_50034_in_binlog = | |
| 5188 |
1/2✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
|
78858 | DBUG_EVALUATE_IF("pretend_version_50034_in_binlog", true, false); |
| 5189 | #endif | ||
| 5190 |
1/2✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
|
78858 | Format_description_log_event s; |
| 5191 | |||
| 5192 |
1/2✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
|
78858 | if (m_binlog_file->is_empty()) { |
| 5193 | /* | ||
| 5194 | The binary log file was empty (probably newly created) | ||
| 5195 | This is the normal case and happens when the user doesn't specify | ||
| 5196 | an extension for the binary log files. | ||
| 5197 | In this case we write a standard header to it. | ||
| 5198 | */ | ||
| 5199 |
2/4✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78858 times.
|
78858 | if (m_binlog_file->write(pointer_cast<const uchar *>(BINLOG_MAGIC), |
| 5200 | BIN_LOG_HEADER_SIZE)) | ||
| 5201 | ✗ | goto err; | |
| 5202 | 78858 | bytes_written += BIN_LOG_HEADER_SIZE; | |
| 5203 | 78858 | write_file_name_to_index_file = true; | |
| 5204 | } | ||
| 5205 | |||
| 5206 | /* | ||
| 5207 | don't set LOG_EVENT_BINLOG_IN_USE_F for the relay log | ||
| 5208 | */ | ||
| 5209 |
2/2✓ Branch 0 taken 26099 times.
✓ Branch 1 taken 52759 times.
|
78858 | if (!is_relay_log) { |
| 5210 | 26099 | s.common_header->flags |= LOG_EVENT_BINLOG_IN_USE_F; | |
| 5211 | } | ||
| 5212 | |||
| 5213 |
2/2✓ Branch 0 taken 52759 times.
✓ Branch 1 taken 26099 times.
|
78858 | if (is_relay_log) { |
| 5214 | /* relay-log */ | ||
| 5215 |
2/2✓ Branch 0 taken 6436 times.
✓ Branch 1 taken 46323 times.
|
52759 | if (relay_log_checksum_alg == binary_log::BINLOG_CHECKSUM_ALG_UNDEF) { |
| 5216 | /* inherit master's A descriptor if one has been received */ | ||
| 5217 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6436 times.
|
6436 | if (opt_replica_sql_verify_checksum == 0) |
| 5218 | /* otherwise use slave's local preference of RL events verification */ | ||
| 5219 | ✗ | relay_log_checksum_alg = binary_log::BINLOG_CHECKSUM_ALG_OFF; | |
| 5220 | else | ||
| 5221 | 6436 | relay_log_checksum_alg = | |
| 5222 | 6436 | static_cast<enum_binlog_checksum_alg>(binlog_checksum_options); | |
| 5223 | } | ||
| 5224 | } | ||
| 5225 | |||
| 5226 |
2/4✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78858 times.
|
78858 | if (!s.is_valid()) goto err; |
| 5227 | 78858 | s.dont_set_created = null_created_arg; | |
| 5228 | /* Set LOG_EVENT_RELAY_LOG_F flag for relay log's FD */ | ||
| 5229 |
2/2✓ Branch 0 taken 52759 times.
✓ Branch 1 taken 26099 times.
|
78858 | if (is_relay_log) s.set_relay_log_event(); |
| 5230 |
2/4✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78858 times.
|
78858 | if (write_event_to_binlog(&s)) goto err; |
| 5231 | |||
| 5232 | /* | ||
| 5233 | We need to revisit this code and improve it. | ||
| 5234 | See further comments in the mysqld. | ||
| 5235 | /Alfranio | ||
| 5236 | */ | ||
| 5237 |
3/4✓ Branch 0 taken 78858 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 68426 times.
✓ Branch 3 taken 10432 times.
|
78858 | if (current_thd) { |
| 5238 | 68426 | Checkable_rwlock *sid_lock = nullptr; | |
| 5239 |
1/2✓ Branch 0 taken 68426 times.
✗ Branch 1 not taken.
|
68426 | Gtid_set logged_gtids_binlog(global_sid_map, global_sid_lock); |
| 5240 | Gtid_set *previous_logged_gtids; | ||
| 5241 | |||
| 5242 |
2/2✓ Branch 0 taken 51317 times.
✓ Branch 1 taken 17109 times.
|
68426 | if (is_relay_log) { |
| 5243 | 51317 | previous_logged_gtids = previous_gtid_set_relaylog; | |
| 5244 | 51317 | sid_lock = previous_gtid_set_relaylog->get_sid_map()->get_sid_lock(); | |
| 5245 | } else { | ||
| 5246 | 17109 | previous_logged_gtids = &logged_gtids_binlog; | |
| 5247 | 17109 | sid_lock = global_sid_lock; | |
| 5248 | } | ||
| 5249 | |||
| 5250 |
2/2✓ Branch 0 taken 42162 times.
✓ Branch 1 taken 26264 times.
|
68426 | if (need_sid_lock) |
| 5251 |
1/2✓ Branch 0 taken 42162 times.
✗ Branch 1 not taken.
|
42162 | sid_lock->wrlock(); |
| 5252 | else | ||
| 5253 |
1/2✓ Branch 0 taken 26264 times.
✗ Branch 1 not taken.
|
26264 | sid_lock->assert_some_wrlock(); |
| 5254 | |||
| 5255 |
2/2✓ Branch 0 taken 17109 times.
✓ Branch 1 taken 51317 times.
|
68426 | if (!is_relay_log) { |
| 5256 | 17109 | const Gtid_set *executed_gtids = gtid_state->get_executed_gtids(); | |
| 5257 | const Gtid_set *gtids_only_in_table = | ||
| 5258 | 17109 | gtid_state->get_gtids_only_in_table(); | |
| 5259 | /* logged_gtids_binlog= executed_gtids - gtids_only_in_table */ | ||
| 5260 |
2/4✓ Branch 0 taken 17109 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 17109 times.
|
17109 | if (logged_gtids_binlog.add_gtid_set(executed_gtids) != |
| 5261 | RETURN_STATUS_OK) { | ||
| 5262 | ✗ | if (need_sid_lock) sid_lock->unlock(); | |
| 5263 | ✗ | goto err; | |
| 5264 | } | ||
| 5265 |
1/2✓ Branch 0 taken 17109 times.
✗ Branch 1 not taken.
|
17109 | logged_gtids_binlog.remove_gtid_set(gtids_only_in_table); |
| 5266 | } | ||
| 5267 |
3/10✓ Branch 0 taken 68426 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 68426 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 68426 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
68426 | DBUG_PRINT("info", ("Generating PREVIOUS_GTIDS for %s file.", |
| 5268 | is_relay_log ? "relaylog" : "binlog")); | ||
| 5269 |
1/2✓ Branch 0 taken 68426 times.
✗ Branch 1 not taken.
|
68426 | Previous_gtids_log_event prev_gtids_ev(previous_logged_gtids); |
| 5270 |
2/2✓ Branch 0 taken 51317 times.
✓ Branch 1 taken 17109 times.
|
68426 | if (is_relay_log) prev_gtids_ev.set_relay_log_event(); |
| 5271 |
3/4✓ Branch 0 taken 42162 times.
✓ Branch 1 taken 26264 times.
✓ Branch 2 taken 42162 times.
✗ Branch 3 not taken.
|
68426 | if (need_sid_lock) sid_lock->unlock(); |
| 5272 |
2/4✓ Branch 0 taken 68426 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 68426 times.
|
68426 | if (write_event_to_binlog(&prev_gtids_ev)) goto err; |
| 5273 |
2/4✓ Branch 0 taken 68426 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 68426 times.
✗ Branch 3 not taken.
|
68426 | } else // !(current_thd) |
| 5274 | { | ||
| 5275 | /* | ||
| 5276 | If the slave was configured before server restart, the server will | ||
| 5277 | generate a new relay log file without having current_thd, but this | ||
| 5278 | new relay log file must have a PREVIOUS_GTIDS event as we now | ||
| 5279 | generate the PREVIOUS_GTIDS event always. | ||
| 5280 | |||
| 5281 | This is only needed for relay log files because the server will add | ||
| 5282 | the PREVIOUS_GTIDS of binary logs (when current_thd==NULL) after | ||
| 5283 | server's GTID initialization. | ||
| 5284 | |||
| 5285 | During server's startup at mysqld_main(), from the binary/relay log | ||
| 5286 | initialization point of view, it will: | ||
| 5287 | 1) Call init_server_components() that will generate a new binary log | ||
| 5288 | file but won't write the PREVIOUS_GTIDS event yet; | ||
| 5289 | 2) Initialize server's GTIDs; | ||
| 5290 | 3) Write the binary log PREVIOUS_GTIDS; | ||
| 5291 | 4) Call init_replica() in where the new relay log file will be created | ||
| 5292 | after initializing relay log's Retrieved_Gtid_Set; | ||
| 5293 | */ | ||
| 5294 |
2/2✓ Branch 0 taken 1442 times.
✓ Branch 1 taken 8990 times.
|
10432 | if (is_relay_log) { |
| 5295 | Sid_map *previous_gtid_sid_map = | ||
| 5296 | 1442 | previous_gtid_set_relaylog->get_sid_map(); | |
| 5297 | 1442 | Checkable_rwlock *sid_lock = previous_gtid_sid_map->get_sid_lock(); | |
| 5298 | |||
| 5299 |
1/2✓ Branch 0 taken 1442 times.
✗ Branch 1 not taken.
|
1442 | if (need_sid_lock) |
| 5300 |
1/2✓ Branch 0 taken 1442 times.
✗ Branch 1 not taken.
|
1442 | sid_lock->wrlock(); |
| 5301 | else | ||
| 5302 | ✗ | sid_lock->assert_some_wrlock(); /* purecov: inspected */ | |
| 5303 | |||
| 5304 |
3/8✓ Branch 0 taken 1442 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1442 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1442 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
1442 | DBUG_PRINT("info", ("Generating PREVIOUS_GTIDS for relaylog file.")); |
| 5305 |
1/2✓ Branch 0 taken 1442 times.
✗ Branch 1 not taken.
|
1442 | Previous_gtids_log_event prev_gtids_ev(previous_gtid_set_relaylog); |
| 5306 | 1442 | prev_gtids_ev.set_relay_log_event(); | |
| 5307 | |||
| 5308 |
2/4✓ Branch 0 taken 1442 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1442 times.
✗ Branch 3 not taken.
|
1442 | if (need_sid_lock) sid_lock->unlock(); |
| 5309 | |||
| 5310 |
2/4✓ Branch 0 taken 1442 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1442 times.
|
1442 | if (write_event_to_binlog(&prev_gtids_ev)) goto err; |
| 5311 |
1/2✓ Branch 0 taken 1442 times.
✗ Branch 1 not taken.
|
1442 | } |
| 5312 | } | ||
| 5313 |
2/2✓ Branch 0 taken 5607 times.
✓ Branch 1 taken 73251 times.
|
78858 | if (extra_description_event) { |
| 5314 | /* | ||
| 5315 | This is a relay log written to by the I/O slave thread. | ||
| 5316 | Write the event so that others can later know the format of this relay | ||
| 5317 | log. | ||
| 5318 | Note that this event is very close to the original event from the | ||
| 5319 | master (it has binlog version of the master, event types of the | ||
| 5320 | master), so this is suitable to parse the next relay log's event. It | ||
| 5321 | has been produced by | ||
| 5322 | Format_description_log_event::Format_description_log_event(char* buf,). | ||
| 5323 | Why don't we want to write the mi_description_event if this | ||
| 5324 | event is for format<4 (3.23 or 4.x): this is because in that case, the | ||
| 5325 | mi_description_event describes the data received from the | ||
| 5326 | master, but not the data written to the relay log (*conversion*), | ||
| 5327 | which is in format 4 (slave's). | ||
| 5328 | */ | ||
| 5329 | /* | ||
| 5330 | Set 'created' to 0, so that in next relay logs this event does not | ||
| 5331 | trigger cleaning actions on the slave in | ||
| 5332 | Format_description_log_event::apply_event_impl(). | ||
| 5333 | */ | ||
| 5334 | 5607 | extra_description_event->created = 0; | |
| 5335 | /* Don't set log_pos in event header */ | ||
| 5336 | 5607 | extra_description_event->set_artificial_event(); | |
| 5337 |
2/4✓ Branch 0 taken 5607 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5607 times.
|
5607 | if (binary_event_serialize(extra_description_event, m_binlog_file)) |
| 5338 | ✗ | goto err; | |
| 5339 | 5607 | bytes_written += extra_description_event->common_header->data_written; | |
| 5340 | } | ||
| 5341 |
2/4✓ Branch 0 taken 78856 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78856 times.
|
78858 | if (m_binlog_file->flush_and_sync()) goto err; |
| 5342 | |||
| 5343 |
1/2✓ Branch 0 taken 78856 times.
✗ Branch 1 not taken.
|
78856 | if (write_file_name_to_index_file) { |
| 5344 |
2/6✓ Branch 0 taken 78856 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78856 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
78856 | DBUG_EXECUTE_IF("crash_create_critical_before_update_index", |
| 5345 | DBUG_SUICIDE();); | ||
| 5346 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78856 times.
|
78856 | assert(my_b_inited(&index_file) != 0); |
| 5347 | |||
| 5348 | /* | ||
| 5349 | The new log file name is appended into crash safe index file after | ||
| 5350 | all the content of index file is copied into the crash safe index | ||
| 5351 | file. Then move the crash safe index file to index file. | ||
| 5352 | */ | ||
| 5353 |
4/6✓ Branch 0 taken 78856 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 78855 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
78856 | DBUG_EXECUTE_IF("simulate_disk_full_on_open_binlog", |
| 5354 | { DBUG_SET("+d,simulate_no_free_space_error"); }); | ||
| 5355 |
5/6✓ Branch 0 taken 78855 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78854 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 78854 times.
|
157711 | if (DBUG_EVALUATE_IF("fault_injection_updating_index", 1, 0) || |
| 5356 |
3/4✓ Branch 0 taken 78855 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 78854 times.
|
78854 | add_log_to_index((uchar *)log_file_name, strlen(log_file_name), |
| 5357 | need_lock_index)) { | ||
| 5358 |
6/10✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
|
2 | DBUG_EXECUTE_IF("simulate_disk_full_on_open_binlog", { |
| 5359 | DBUG_SET("-d,simulate_file_write_error"); | ||
| 5360 | DBUG_SET("-d,simulate_no_free_space_error"); | ||
| 5361 | DBUG_SET("-d,simulate_disk_full_on_open_binlog"); | ||
| 5362 | }); | ||
| 5363 | 2 | goto err; | |
| 5364 | } | ||
| 5365 | |||
| 5366 |
2/6✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78854 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
78854 | DBUG_EXECUTE_IF("crash_create_after_update_index", DBUG_SUICIDE();); |
| 5367 | } | ||
| 5368 | |||
| 5369 | 78854 | atomic_log_state = LOG_OPENED; | |
| 5370 | /* | ||
| 5371 | At every rotate memorize the last transaction counter state to use it as | ||
| 5372 | offset at logging the transaction logical timestamps. | ||
| 5373 | */ | ||
| 5374 |
1/2✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
|
78854 | m_dependency_tracker.rotate(); |
| 5375 | |||
| 5376 |
1/2✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
|
78854 | close_purge_index_file(); |
| 5377 | |||
| 5378 |
1/2✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
|
78854 | update_binlog_end_pos(); |
| 5379 | 78854 | return false; | |
| 5380 | |||
| 5381 | 2 | err: | |
| 5382 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
2 | if (is_inited_purge_index_file()) |
| 5383 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | purge_index_entry(nullptr, nullptr, need_lock_index); |
| 5384 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | close_purge_index_file(); |
| 5385 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (binlog_error_action == ABORT_SERVER) { |
| 5386 | ✗ | exec_binlog_error_action_abort( | |
| 5387 | "Either disk is full, file system is read only or " | ||
| 5388 | "there was an encryption error while opening the binlog. " | ||
| 5389 | "Aborting the server."); | ||
| 5390 | } else { | ||
| 5391 |
9/18✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 2 times.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✓ Branch 15 taken 2 times.
✓ Branch 16 taken 2 times.
✗ Branch 17 not taken.
|
2 | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_USE_FOR_LOGGING, |
| 5392 | (new_name) ? new_name : name, errno); | ||
| 5393 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | close(LOG_CLOSE_INDEX, false, need_lock_index); |
| 5394 | } | ||
| 5395 | 2 | return true; | |
| 5396 | 78863 | } | |
| 5397 | |||
| 5398 | /** | ||
| 5399 | Move crash safe index file to index file. | ||
| 5400 | |||
| 5401 | @param need_lock_index If true, LOCK_index will be acquired; | ||
| 5402 | otherwise it should already be held. | ||
| 5403 | |||
| 5404 | @retval 0 ok | ||
| 5405 | @retval -1 error | ||
| 5406 | */ | ||
| 5407 | 102885 | int MYSQL_BIN_LOG::move_crash_safe_index_file_to_index_file( | |
| 5408 | bool need_lock_index) { | ||
| 5409 | 102885 | int error = 0; | |
| 5410 | 102885 | File fd = -1; | |
| 5411 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | DBUG_TRACE; |
| 5412 | 102885 | int failure_trials = MYSQL_BIN_LOG::MAX_RETRIES_FOR_DELETE_RENAME_FAILURE; | |
| 5413 | 102885 | bool file_rename_status = false, file_delete_status = false; | |
| 5414 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | THD *thd = current_thd; |
| 5415 | |||
| 5416 |
2/2✓ Branch 0 taken 20832 times.
✓ Branch 1 taken 82053 times.
|
102885 | if (need_lock_index) |
| 5417 |
1/2✓ Branch 0 taken 20832 times.
✗ Branch 1 not taken.
|
20832 | mysql_mutex_lock(&LOCK_index); |
| 5418 | else | ||
| 5419 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 5420 | |||
| 5421 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | if (my_b_inited(&index_file)) { |
| 5422 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | end_io_cache(&index_file); |
| 5423 |
2/4✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102885 times.
|
102885 | if (mysql_file_close(index_file.file, MYF(0)) < 0) { |
| 5424 | ✗ | error = -1; | |
| 5425 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_CLOSE_INDEX_FILE_WHILE_REBUILDING, | |
| 5426 | index_file_name); | ||
| 5427 | /* | ||
| 5428 | Delete Crash safe index file here and recover the binlog.index | ||
| 5429 | state(index_file io_cache) from old binlog.index content. | ||
| 5430 | */ | ||
| 5431 | ✗ | mysql_file_delete(key_file_binlog_index, crash_safe_index_file_name, | |
| 5432 | MYF(0)); | ||
| 5433 | |||
| 5434 | ✗ | goto recoverable_err; | |
| 5435 | } | ||
| 5436 | |||
| 5437 | /* | ||
| 5438 | Sometimes an outsider can lock index files for temporary viewing | ||
| 5439 | purpose. For eg: MEB locks binlog.index/relaylog.index to view | ||
| 5440 | the content of the file. During that small period of time, deletion | ||
| 5441 | of the file is not possible on some platforms(Eg: Windows) | ||
| 5442 | Server should retry the delete operation for few times instead of | ||
| 5443 | panicking immediately. | ||
| 5444 | */ | ||
| 5445 |
3/4✓ Branch 0 taken 102885 times.
✓ Branch 1 taken 102884 times.
✓ Branch 2 taken 102885 times.
✗ Branch 3 not taken.
|
205769 | while ((file_delete_status == false) && (failure_trials > 0)) { |
| 5446 |
2/4✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102885 times.
|
102885 | if (DBUG_EVALUATE_IF("force_index_file_delete_failure", 1, 0)) break; |
| 5447 | |||
| 5448 |
2/12✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102885 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
102885 | DBUG_EXECUTE_IF("simulate_index_file_delete_failure", { |
| 5449 | /* This simulation causes the delete to fail */ | ||
| 5450 | static char first_char = index_file_name[0]; | ||
| 5451 | index_file_name[0] = 0; | ||
| 5452 | sql_print_information("Retrying delete"); | ||
| 5453 | if (failure_trials == 1) index_file_name[0] = first_char; | ||
| 5454 | };); | ||
| 5455 |
1/2✓ Branch 0 taken 102884 times.
✗ Branch 1 not taken.
|
102885 | file_delete_status = !(mysql_file_delete(key_file_binlog_index, |
| 5456 | index_file_name, MYF(MY_WME))); | ||
| 5457 | 102884 | --failure_trials; | |
| 5458 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 102884 times.
|
102884 | if (!file_delete_status) { |
| 5459 | ✗ | my_sleep(1000); | |
| 5460 | /* Clear the error before retrying. */ | ||
| 5461 | ✗ | if (failure_trials > 0) thd->clear_error(); | |
| 5462 | } | ||
| 5463 | } | ||
| 5464 | |||
| 5465 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 102884 times.
|
102884 | if (!file_delete_status) { |
| 5466 | ✗ | error = -1; | |
| 5467 | ✗ | LogErr(ERROR_LEVEL, | |
| 5468 | ER_BINLOG_FAILED_TO_DELETE_INDEX_FILE_WHILE_REBUILDING, | ||
| 5469 | index_file_name); | ||
| 5470 | /* | ||
| 5471 | Delete Crash safe file index file here and recover the binlog.index | ||
| 5472 | state(index_file io_cache) from old binlog.index content. | ||
| 5473 | */ | ||
| 5474 | ✗ | mysql_file_delete(key_file_binlog_index, crash_safe_index_file_name, | |
| 5475 | MYF(0)); | ||
| 5476 | |||
| 5477 | ✗ | goto recoverable_err; | |
| 5478 | } | ||
| 5479 | } | ||
| 5480 | |||
| 5481 |
2/6✓ Branch 0 taken 102884 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102884 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
102884 | DBUG_EXECUTE_IF("crash_create_before_rename_index_file", DBUG_SUICIDE();); |
| 5482 | /* | ||
| 5483 | Sometimes an outsider can lock index files for temporary viewing | ||
| 5484 | purpose. For eg: MEB locks binlog.index/relaylog.index to view | ||
| 5485 | the content of the file. During that small period of time, rename | ||
| 5486 | of the file is not possible on some platforms(Eg: Windows) | ||
| 5487 | Server should retry the rename operation for few times instead of panicking | ||
| 5488 | immediately. | ||
| 5489 | */ | ||
| 5490 | 102884 | failure_trials = MYSQL_BIN_LOG::MAX_RETRIES_FOR_DELETE_RENAME_FAILURE; | |
| 5491 |
3/4✓ Branch 0 taken 102884 times.
✓ Branch 1 taken 102885 times.
✓ Branch 2 taken 102884 times.
✗ Branch 3 not taken.
|
205769 | while ((file_rename_status == false) && (failure_trials > 0)) { |
| 5492 |
2/12✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102885 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
102884 | DBUG_EXECUTE_IF("simulate_crash_safe_index_file_rename_failure", { |
| 5493 | /* This simulation causes the rename to fail */ | ||
| 5494 | static char first_char = index_file_name[0]; | ||
| 5495 | index_file_name[0] = 0; | ||
| 5496 | sql_print_information("Retrying rename"); | ||
| 5497 | if (failure_trials == 1) index_file_name[0] = first_char; | ||
| 5498 | };); | ||
| 5499 | 102885 | file_rename_status = | |
| 5500 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | !(my_rename(crash_safe_index_file_name, index_file_name, MYF(MY_WME))); |
| 5501 | 102885 | --failure_trials; | |
| 5502 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 102885 times.
|
102885 | if (!file_rename_status) { |
| 5503 | ✗ | my_sleep(1000); | |
| 5504 | /* Clear the error before retrying. */ | ||
| 5505 | ✗ | if (failure_trials > 0) thd->clear_error(); | |
| 5506 | } | ||
| 5507 | } | ||
| 5508 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 102885 times.
|
102885 | if (!file_rename_status) { |
| 5509 | ✗ | error = -1; | |
| 5510 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_RENAME_INDEX_FILE_WHILE_REBUILDING, | |
| 5511 | index_file_name); | ||
| 5512 | ✗ | goto fatal_err; | |
| 5513 | } | ||
| 5514 |
2/6✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102885 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
102885 | DBUG_EXECUTE_IF("crash_create_after_rename_index_file", DBUG_SUICIDE();); |
| 5515 | |||
| 5516 | 102885 | recoverable_err: | |
| 5517 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | if ((fd = mysql_file_open(key_file_binlog_index, index_file_name, |
| 5518 | 102885 | O_RDWR | O_CREAT, MYF(MY_WME))) < 0 || | |
| 5519 |
4/8✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 102885 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 102885 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 102884 times.
|
205769 | mysql_file_sync(fd, MYF(MY_WME)) || |
| 5520 |
3/6✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 102884 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 102884 times.
|
102885 | init_io_cache_ext(&index_file, fd, IO_SIZE, READ_CACHE, |
| 5521 | mysql_file_seek(fd, 0L, MY_SEEK_END, MYF(0)), false, | ||
| 5522 | MYF(MY_WME | MY_WAIT_IF_FULL), | ||
| 5523 | key_file_binlog_index_cache)) { | ||
| 5524 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_OPEN_INDEX_FILE_AFTER_REBUILDING, | |
| 5525 | index_file_name); | ||
| 5526 | ✗ | goto fatal_err; | |
| 5527 | } | ||
| 5528 | |||
| 5529 |
3/4✓ Branch 0 taken 20832 times.
✓ Branch 1 taken 82052 times.
✓ Branch 2 taken 20833 times.
✗ Branch 3 not taken.
|
102884 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 5530 | 102885 | return error; | |
| 5531 | |||
| 5532 | ✗ | fatal_err: | |
| 5533 | /* | ||
| 5534 | This situation is very very rare to happen (unless there is some serious | ||
| 5535 | memory related issues like OOM) and should be treated as fatal error. | ||
| 5536 | Hence it is better to bring down the server without respecting | ||
| 5537 | 'binlog_error_action' value here. | ||
| 5538 | */ | ||
| 5539 | ✗ | exec_binlog_error_action_abort( | |
| 5540 | "MySQL server failed to update the " | ||
| 5541 | "binlog.index file's content properly. " | ||
| 5542 | "It might not be in sync with available " | ||
| 5543 | "binlogs and the binlog.index file state is in " | ||
| 5544 | "unrecoverable state. Aborting the server."); | ||
| 5545 | /* | ||
| 5546 | Server is aborted in the above function. | ||
| 5547 | This is dead code to make compiler happy. | ||
| 5548 | */ | ||
| 5549 | ✗ | return error; | |
| 5550 | 102885 | } | |
| 5551 | |||
| 5552 | /** | ||
| 5553 | Append log file name to index file. | ||
| 5554 | |||
| 5555 | - To make crash safe, we copy all the content of index file | ||
| 5556 | to crash safe index file firstly and then append the log | ||
| 5557 | file name to the crash safe index file. Finally move the | ||
| 5558 | crash safe index file to index file. | ||
| 5559 | |||
| 5560 | @retval | ||
| 5561 | 0 ok | ||
| 5562 | @retval | ||
| 5563 | -1 error | ||
| 5564 | */ | ||
| 5565 | 78855 | int MYSQL_BIN_LOG::add_log_to_index(uchar *log_name, size_t log_name_len, | |
| 5566 | bool need_lock_index) { | ||
| 5567 |
1/2✓ Branch 0 taken 78855 times.
✗ Branch 1 not taken.
|
78855 | DBUG_TRACE; |
| 5568 | |||
| 5569 |
2/4✓ Branch 0 taken 78855 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78855 times.
|
78855 | if (open_crash_safe_index_file()) { |
| 5570 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_TMP_INDEX, | |
| 5571 | "MYSQL_BIN_LOG::add_log_to_index"); | ||
| 5572 | ✗ | goto err; | |
| 5573 | } | ||
| 5574 | |||
| 5575 |
3/4✓ Branch 0 taken 78855 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 78854 times.
|
78855 | if (copy_file(&index_file, &crash_safe_index_file, 0)) { |
| 5576 |
8/16✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
|
1 | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_COPY_INDEX_TO_TMP, |
| 5577 | "MYSQL_BIN_LOG::add_log_to_index"); | ||
| 5578 | 1 | goto err; | |
| 5579 | } | ||
| 5580 | |||
| 5581 |
1/2✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
|
78854 | if (my_b_write(&crash_safe_index_file, log_name, log_name_len) || |
| 5582 |
2/4✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78854 times.
✗ Branch 3 not taken.
|
78854 | my_b_write(&crash_safe_index_file, pointer_cast<const uchar *>("\n"), |
| 5583 | 78854 | 1) || | |
| 5584 |
4/8✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78854 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 78854 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 78853 times.
|
236561 | flush_io_cache(&crash_safe_index_file) || |
| 5585 |
2/4✓ Branch 0 taken 78853 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78853 times.
|
78854 | mysql_file_sync(crash_safe_index_file.file, MYF(MY_WME))) { |
| 5586 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_APPEND_LOG_TO_TMP_INDEX, log_name); | |
| 5587 | ✗ | goto err; | |
| 5588 | } | ||
| 5589 | |||
| 5590 |
2/4✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78854 times.
|
78853 | if (close_crash_safe_index_file()) { |
| 5591 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_CLOSE_TMP_INDEX, | |
| 5592 | "MYSQL_BIN_LOG::add_log_to_index"); | ||
| 5593 | ✗ | goto err; | |
| 5594 | } | ||
| 5595 | |||
| 5596 |
2/4✓ Branch 0 taken 78854 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 78854 times.
|
78854 | if (move_crash_safe_index_file_to_index_file(need_lock_index)) { |
| 5597 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_MOVE_TMP_TO_INDEX, | |
| 5598 | "MYSQL_BIN_LOG::add_log_to_index"); | ||
| 5599 | ✗ | goto err; | |
| 5600 | } | ||
| 5601 | |||
| 5602 | 78854 | return 0; | |
| 5603 | |||
| 5604 | 1 | err: | |
| 5605 | 1 | return -1; | |
| 5606 | 78855 | } | |
| 5607 | |||
| 5608 | 1449425 | int MYSQL_BIN_LOG::get_current_log(LOG_INFO *linfo, | |
| 5609 | bool need_lock_log /*true*/) { | ||
| 5610 |
2/2✓ Branch 0 taken 77297 times.
✓ Branch 1 taken 1372128 times.
|
1449425 | if (need_lock_log) mysql_mutex_lock(&LOCK_log); |
| 5611 | 1449425 | int ret = raw_get_current_log(linfo); | |
| 5612 |
2/2✓ Branch 0 taken 77297 times.
✓ Branch 1 taken 1372128 times.
|
1449425 | if (need_lock_log) mysql_mutex_unlock(&LOCK_log); |
| 5613 | 1449425 | return ret; | |
| 5614 | } | ||
| 5615 | |||
| 5616 | 1449981 | int MYSQL_BIN_LOG::raw_get_current_log(LOG_INFO *linfo) { | |
| 5617 | 1449981 | strmake(linfo->log_file_name, log_file_name, | |
| 5618 | sizeof(linfo->log_file_name) - 1); | ||
| 5619 | 1449981 | linfo->pos = m_binlog_file->position(); | |
| 5620 | 1449981 | linfo->encrypted_header_size = m_binlog_file->get_encrypted_header_size(); | |
| 5621 | 1449981 | return 0; | |
| 5622 | } | ||
| 5623 | |||
| 5624 | 9461 | static bool check_write_error_code(uint error_code) { | |
| 5625 |
2/2✓ Branch 0 taken 9316 times.
✓ Branch 1 taken 13 times.
|
9329 | return error_code == ER_TRANS_CACHE_FULL || |
| 5626 |
6/6✓ Branch 0 taken 9329 times.
✓ Branch 1 taken 132 times.
✓ Branch 2 taken 9243 times.
✓ Branch 3 taken 73 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 9242 times.
|
18790 | error_code == ER_STMT_CACHE_FULL || error_code == ER_ERROR_ON_WRITE || |
| 5627 | 9461 | error_code == ER_BINLOG_LOGGING_IMPOSSIBLE; | |
| 5628 | } | ||
| 5629 | |||
| 5630 | 9823 | bool MYSQL_BIN_LOG::check_write_error(const THD *thd) { | |
| 5631 |
1/2✓ Branch 0 taken 9833 times.
✗ Branch 1 not taken.
|
9823 | DBUG_TRACE; |
| 5632 | |||
| 5633 |
3/4✓ Branch 0 taken 9826 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4304 times.
✓ Branch 3 taken 5522 times.
|
9833 | if (!thd->is_error()) return false; |
| 5634 | |||
| 5635 | 5522 | bool checked = check_write_error_code(thd->get_stmt_da()->mysql_errno()); | |
| 5636 | |||
| 5637 |
2/2✓ Branch 0 taken 5300 times.
✓ Branch 1 taken 225 times.
|
5525 | if (!checked) { |
| 5638 | /* Check all conditions for one that matches the expected error */ | ||
| 5639 | const Sql_condition *err; | ||
| 5640 | Diagnostics_area::Sql_condition_iterator it = | ||
| 5641 |
1/2✓ Branch 0 taken 5299 times.
✗ Branch 1 not taken.
|
5300 | thd->get_stmt_da()->sql_conditions(); |
| 5642 |
6/8✓ Branch 0 taken 9240 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3941 times.
✓ Branch 3 taken 5299 times.
✓ Branch 4 taken 3941 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3941 times.
✓ Branch 7 taken 5299 times.
|
9240 | while ((err = it++) != nullptr && !checked) { |
| 5643 | 3941 | checked = check_write_error_code(err->mysql_errno()); | |
| 5644 | } | ||
| 5645 | } | ||
| 5646 |
3/10✓ Branch 0 taken 5520 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5529 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 5529 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
5524 | DBUG_PRINT("return", ("checked: %s", YESNO(checked))); |
| 5647 | 5529 | return checked; | |
| 5648 | 9833 | } | |
| 5649 | |||
| 5650 | 115 | void MYSQL_BIN_LOG::report_cache_write_error(THD *thd, bool is_transactional) { | |
| 5651 |
1/2✓ Branch 0 taken 115 times.
✗ Branch 1 not taken.
|
115 | DBUG_TRACE; |
| 5652 | |||
| 5653 | 115 | write_error = true; | |
| 5654 | |||
| 5655 |
2/4✓ Branch 0 taken 115 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 115 times.
|
115 | if (check_write_error(thd)) return; |
| 5656 | |||
| 5657 |
3/4✓ Branch 0 taken 115 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 77 times.
✓ Branch 3 taken 38 times.
|
115 | if (my_errno() == EFBIG) { |
| 5658 |
2/2✓ Branch 0 taken 70 times.
✓ Branch 1 taken 7 times.
|
77 | if (is_transactional) { |
| 5659 |
1/2✓ Branch 0 taken 70 times.
✗ Branch 1 not taken.
|
70 | my_error(ER_TRANS_CACHE_FULL, MYF(MY_WME)); |
| 5660 | } else { | ||
| 5661 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | my_error(ER_STMT_CACHE_FULL, MYF(MY_WME)); |
| 5662 | } | ||
| 5663 | } else { | ||
| 5664 | char errbuf[MYSYS_STRERROR_SIZE]; | ||
| 5665 |
1/2✓ Branch 0 taken 38 times.
✗ Branch 1 not taken.
|
38 | my_error(ER_ERROR_ON_WRITE, MYF(MY_WME), name, errno, |
| 5666 |
1/2✓ Branch 0 taken 38 times.
✗ Branch 1 not taken.
|
38 | my_strerror(errbuf, sizeof(errbuf), errno)); |
| 5667 | } | ||
| 5668 | |||
| 5669 | #ifdef WITH_WSREP | ||
| 5670 | /* | ||
| 5671 | If wsrep transaction is active and binlog emulation is on, binlog | ||
| 5672 | write error may leave transaction without any registered htons. | ||
| 5673 | This makes wsrep rollback hooks to be skipped and the transaction | ||
| 5674 | will remain alive in wsrep world after rollback. Register binlog | ||
| 5675 | hton here to ensure that rollback happens in full only when the | ||
| 5676 | session is in multi stmt transaction mode (i.e, either | ||
| 5677 | autocommit=OFF or when the transaction is started with explicit | ||
| 5678 | BEGIN). | ||
| 5679 | */ | ||
| 5680 |
7/10✓ Branch 0 taken 115 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 98 times.
✓ Branch 4 taken 17 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 17 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 16 times.
✓ Branch 9 taken 1 times.
|
115 | if (WSREP_EMULATE_BINLOG(thd)) { |
| 5681 |
5/6✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 12 times.
✓ Branch 5 taken 4 times.
|
16 | if (is_transactional && thd->in_multi_stmt_transaction_mode()) |
| 5682 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | trans_register_ha(thd, true, binlog_hton, NULL); |
| 5683 |
1/2✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
|
16 | trans_register_ha(thd, false, binlog_hton, NULL); |
| 5684 | } | ||
| 5685 | #endif /* WITH_WSREP */ | ||
| 5686 |
1/2✓ Branch 0 taken 115 times.
✗ Branch 1 not taken.
|
115 | } |
| 5687 | |||
| 5688 | 6166643 | static int compare_log_name(const char *log_1, const char *log_2) { | |
| 5689 | 6166643 | const char *log_1_basename = log_1 + dirname_length(log_1); | |
| 5690 | 6166656 | const char *log_2_basename = log_2 + dirname_length(log_2); | |
| 5691 | |||
| 5692 | 6166664 | return strcmp(log_1_basename, log_2_basename); | |
| 5693 | } | ||
| 5694 | |||
| 5695 | /** | ||
| 5696 | Find the position in the log-index-file for the given log name. | ||
| 5697 | |||
| 5698 | @param[out] linfo The found log file name will be stored here, along | ||
| 5699 | with the byte offset of the next log file name in the index file. | ||
| 5700 | @param log_name Filename to find in the index file, or NULL if we | ||
| 5701 | want to read the first entry. | ||
| 5702 | @param need_lock_index If false, this function acquires LOCK_index; | ||
| 5703 | otherwise the lock should already be held by the caller. | ||
| 5704 | |||
| 5705 | @note | ||
| 5706 | On systems without the truncate function the file will end with one or | ||
| 5707 | more empty lines. These will be ignored when reading the file. | ||
| 5708 | |||
| 5709 | @retval | ||
| 5710 | 0 ok | ||
| 5711 | @retval | ||
| 5712 | LOG_INFO_EOF End of log-index-file found | ||
| 5713 | @retval | ||
| 5714 | LOG_INFO_IO Got IO error while reading file | ||
| 5715 | */ | ||
| 5716 | |||
| 5717 | 241685 | int MYSQL_BIN_LOG::find_log_pos(LOG_INFO *linfo, const char *log_name, | |
| 5718 | bool need_lock_index) { | ||
| 5719 | 241685 | int error = 0; | |
| 5720 | 241685 | char *full_fname = linfo->log_file_name; | |
| 5721 | char full_log_name[FN_REFLEN], fname[FN_REFLEN]; | ||
| 5722 |
1/2✓ Branch 0 taken 241685 times.
✗ Branch 1 not taken.
|
241685 | DBUG_TRACE; |
| 5723 | 241685 | full_log_name[0] = full_fname[0] = 0; | |
| 5724 | |||
| 5725 | /* | ||
| 5726 | Mutex needed because we need to make sure the file pointer does not | ||
| 5727 | move from under our feet | ||
| 5728 | */ | ||
| 5729 |
2/2✓ Branch 0 taken 85494 times.
✓ Branch 1 taken 156191 times.
|
241685 | if (need_lock_index) |
| 5730 |
1/2✓ Branch 0 taken 85494 times.
✗ Branch 1 not taken.
|
85494 | mysql_mutex_lock(&LOCK_index); |
| 5731 | else | ||
| 5732 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 5733 | |||
| 5734 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 241684 times.
|
241685 | if (!my_b_inited(&index_file)) { |
| 5735 | 1 | error = LOG_INFO_IO; | |
| 5736 | 1 | goto end; | |
| 5737 | } | ||
| 5738 | |||
| 5739 | // extend relative paths for log_name to be searched | ||
| 5740 |
2/2✓ Branch 0 taken 93418 times.
✓ Branch 1 taken 148266 times.
|
241684 | if (log_name) { |
| 5741 |
2/4✓ Branch 0 taken 93418 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 93418 times.
|
93418 | if (normalize_binlog_name(full_log_name, log_name, is_relay_log)) { |
| 5742 | ✗ | error = LOG_INFO_EOF; | |
| 5743 | ✗ | goto end; | |
| 5744 | } | ||
| 5745 | } | ||
| 5746 | |||
| 5747 |
3/10✓ Branch 0 taken 241684 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 241684 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 241684 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
241684 | DBUG_PRINT("enter", ("log_name: %s, full_log_name: %s", |
| 5748 | log_name ? log_name : "NULL", full_log_name)); | ||
| 5749 | |||
| 5750 | /* As the file is flushed, we can't get an error here */ | ||
| 5751 |
1/2✓ Branch 0 taken 241684 times.
✗ Branch 1 not taken.
|
241684 | my_b_seek(&index_file, (my_off_t)0); |
| 5752 | |||
| 5753 | for (;;) { | ||
| 5754 | size_t length; | ||
| 5755 | 2279258 | my_off_t offset = my_b_tell(&index_file); | |
| 5756 | |||
| 5757 |
3/4✓ Branch 0 taken 2279258 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 2279244 times.
|
2279258 | DBUG_EXECUTE_IF("simulate_find_log_pos_error", error = LOG_INFO_EOF; |
| 5758 | break;); | ||
| 5759 | /* If we get 0 or 1 characters, this is the end of the file */ | ||
| 5760 |
3/4✓ Branch 0 taken 2279258 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19265 times.
✓ Branch 3 taken 2259993 times.
|
2279258 | if ((length = my_b_gets(&index_file, fname, FN_REFLEN)) <= 1) { |
| 5761 | /* Did not find the given entry; Return not found or error */ | ||
| 5762 |
1/2✓ Branch 0 taken 19265 times.
✗ Branch 1 not taken.
|
19265 | error = !index_file.error ? LOG_INFO_EOF : LOG_INFO_IO; |
| 5763 | 19265 | break; | |
| 5764 | } | ||
| 5765 | |||
| 5766 | // extend relative paths and match against full path | ||
| 5767 |
2/4✓ Branch 0 taken 2259993 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2259993 times.
|
2259993 | if (normalize_binlog_name(full_fname, fname, is_relay_log)) { |
| 5768 | ✗ | error = LOG_INFO_EOF; | |
| 5769 | ✗ | break; | |
| 5770 | } | ||
| 5771 | // if the log entry matches, null string matching anything | ||
| 5772 |
7/8✓ Branch 0 taken 2115939 times.
✓ Branch 1 taken 144054 times.
✓ Branch 2 taken 2115939 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 78365 times.
✓ Branch 5 taken 2037574 times.
✓ Branch 6 taken 222419 times.
✓ Branch 7 taken 2037574 times.
|
2259993 | if (!log_name || !compare_log_name(full_fname, full_log_name)) { |
| 5773 |
3/8✓ Branch 0 taken 222419 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 222419 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 222419 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
222419 | DBUG_PRINT("info", ("Found log file entry")); |
| 5774 | 222419 | linfo->index_file_start_offset = offset; | |
| 5775 | 222419 | linfo->index_file_offset = my_b_tell(&index_file); | |
| 5776 | 222419 | break; | |
| 5777 | } | ||
| 5778 | 2037574 | linfo->entry_index++; | |
| 5779 | 2037574 | } | |
| 5780 | |||
| 5781 | 241685 | end: | |
| 5782 |
3/4✓ Branch 0 taken 85494 times.
✓ Branch 1 taken 156191 times.
✓ Branch 2 taken 85494 times.
✗ Branch 3 not taken.
|
241685 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 5783 | 241685 | return error; | |
| 5784 | 241685 | } | |
| 5785 | |||
| 5786 | /** | ||
| 5787 | Find the position in the log-index-file for the given log name. | ||
| 5788 | |||
| 5789 | @param[out] linfo The filename will be stored here, along with the | ||
| 5790 | byte offset of the next filename in the index file. | ||
| 5791 | |||
| 5792 | @param need_lock_index If true, LOCK_index will be acquired; | ||
| 5793 | otherwise it should already be held by the caller. | ||
| 5794 | |||
| 5795 | @note | ||
| 5796 | - Before calling this function, one has to call find_log_pos() | ||
| 5797 | to set up 'linfo' | ||
| 5798 | - Mutex needed because we need to make sure the file pointer does not move | ||
| 5799 | from under our feet | ||
| 5800 | |||
| 5801 | @retval 0 ok | ||
| 5802 | @retval LOG_INFO_EOF End of log-index-file found | ||
| 5803 | @retval LOG_INFO_IO Got IO error while reading file | ||
| 5804 | */ | ||
| 5805 | 637420 | int MYSQL_BIN_LOG::find_next_log(LOG_INFO *linfo, bool need_lock_index) { | |
| 5806 | 637420 | int error = 0; | |
| 5807 | size_t length; | ||
| 5808 | char fname[FN_REFLEN]; | ||
| 5809 | 637420 | char *full_fname = linfo->log_file_name; | |
| 5810 | |||
| 5811 |
2/2✓ Branch 0 taken 294699 times.
✓ Branch 1 taken 342721 times.
|
637420 | if (need_lock_index) |
| 5812 |
1/2✓ Branch 0 taken 294699 times.
✗ Branch 1 not taken.
|
294699 | mysql_mutex_lock(&LOCK_index); |
| 5813 | else | ||
| 5814 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 5815 | |||
| 5816 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 637420 times.
|
637420 | if (!my_b_inited(&index_file)) { |
| 5817 | ✗ | error = LOG_INFO_IO; | |
| 5818 | ✗ | goto err; | |
| 5819 | } | ||
| 5820 | /* As the file is flushed, we can't get an error here */ | ||
| 5821 |
1/2✓ Branch 0 taken 637420 times.
✗ Branch 1 not taken.
|
637420 | my_b_seek(&index_file, linfo->index_file_offset); |
| 5822 | |||
| 5823 | 637420 | linfo->index_file_start_offset = linfo->index_file_offset; | |
| 5824 |
3/4✓ Branch 0 taken 637420 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 77753 times.
✓ Branch 3 taken 559667 times.
|
637420 | if ((length = my_b_gets(&index_file, fname, FN_REFLEN)) <= 1) { |
| 5825 |
1/2✓ Branch 0 taken 77753 times.
✗ Branch 1 not taken.
|
77753 | error = !index_file.error ? LOG_INFO_EOF : LOG_INFO_IO; |
| 5826 | 77753 | goto err; | |
| 5827 | } | ||
| 5828 | |||
| 5829 |
1/2✓ Branch 0 taken 559667 times.
✗ Branch 1 not taken.
|
559667 | if (fname[0] != 0) { |
| 5830 |
2/4✓ Branch 0 taken 559667 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 559667 times.
|
559667 | if (normalize_binlog_name(full_fname, fname, is_relay_log)) { |
| 5831 | ✗ | error = LOG_INFO_EOF; | |
| 5832 | ✗ | goto err; | |
| 5833 | } | ||
| 5834 | 559667 | length = strlen(full_fname); | |
| 5835 | } | ||
| 5836 | |||
| 5837 | 559667 | linfo->index_file_offset = my_b_tell(&index_file); | |
| 5838 | |||
| 5839 | 637420 | err: | |
| 5840 |
3/4✓ Branch 0 taken 294699 times.
✓ Branch 1 taken 342721 times.
✓ Branch 2 taken 294699 times.
✗ Branch 3 not taken.
|
637420 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 5841 | 637420 | return error; | |
| 5842 | } | ||
| 5843 | |||
| 5844 | /** | ||
| 5845 | Find the relay log name following the given name from relay log index file. | ||
| 5846 | |||
| 5847 | @param[in,out] log_name The name is full path name. | ||
| 5848 | |||
| 5849 | @return return 0 if it finds next relay log. Otherwise return the error code. | ||
| 5850 | */ | ||
| 5851 | ✗ | int MYSQL_BIN_LOG::find_next_relay_log(char log_name[FN_REFLEN + 1]) { | |
| 5852 | ✗ | LOG_INFO info; | |
| 5853 | int error; | ||
| 5854 | char relative_path_name[FN_REFLEN + 1]; | ||
| 5855 | |||
| 5856 | ✗ | if (fn_format(relative_path_name, log_name + dirname_length(log_name), | |
| 5857 | ✗ | mysql_data_home, "", 0) == NullS) | |
| 5858 | ✗ | return 1; | |
| 5859 | |||
| 5860 | ✗ | mysql_mutex_lock(&LOCK_index); | |
| 5861 | |||
| 5862 | ✗ | error = find_log_pos(&info, relative_path_name, false); | |
| 5863 | ✗ | if (error == 0) { | |
| 5864 | ✗ | error = find_next_log(&info, false); | |
| 5865 | ✗ | if (error == 0) strcpy(log_name, info.log_file_name); | |
| 5866 | } | ||
| 5867 | |||
| 5868 | ✗ | mysql_mutex_unlock(&LOCK_index); | |
| 5869 | ✗ | return error; | |
| 5870 | } | ||
| 5871 | |||
| 5872 | 14630 | std::pair<int, std::list<std::string>> MYSQL_BIN_LOG::get_log_index( | |
| 5873 | bool need_lock_index) { | ||
| 5874 |
1/2✓ Branch 0 taken 14630 times.
✗ Branch 1 not taken.
|
14630 | DBUG_TRACE; |
| 5875 | 14630 | LOG_INFO log_info; | |
| 5876 | |||
| 5877 |
2/2✓ Branch 0 taken 4212 times.
✓ Branch 1 taken 10418 times.
|
14630 | if (need_lock_index) |
| 5878 |
1/2✓ Branch 0 taken 4212 times.
✗ Branch 1 not taken.
|
4212 | mysql_mutex_lock(&LOCK_index); |
| 5879 | else | ||
| 5880 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 5881 | |||
| 5882 | 14630 | std::list<std::string> filename_list; | |
| 5883 | 14630 | int error = 0; | |
| 5884 | 14630 | for (error = | |
| 5885 |
1/2✓ Branch 0 taken 14630 times.
✗ Branch 1 not taken.
|
14630 | this->find_log_pos(&log_info, nullptr, false /*need_lock_index*/); |
| 5886 |
2/2✓ Branch 0 taken 274114 times.
✓ Branch 1 taken 14630 times.
|
288744 | error == 0; |
| 5887 | 274114 | error = this->find_next_log(&log_info, false /*need_lock_index*/)) { | |
| 5888 |
3/6✓ Branch 0 taken 274114 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 274114 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 274114 times.
✗ Branch 5 not taken.
|
274114 | filename_list.push_back(std::string(log_info.log_file_name)); |
| 5889 | } | ||
| 5890 | |||
| 5891 |
3/4✓ Branch 0 taken 4212 times.
✓ Branch 1 taken 10418 times.
✓ Branch 2 taken 4212 times.
✗ Branch 3 not taken.
|
14630 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 5892 | |||
| 5893 |
1/2✓ Branch 0 taken 14630 times.
✗ Branch 1 not taken.
|
29260 | return std::make_pair(error, filename_list); |
| 5894 | 14630 | } | |
| 5895 | |||
| 5896 | /** | ||
| 5897 | Removes files, as part of a RESET MASTER or RESET SLAVE statement, | ||
| 5898 | by deleting all logs referred to in the index file and the index | ||
| 5899 | file. Then, it creates a new index file and a new log file. | ||
| 5900 | |||
| 5901 | The new index file will only contain the new log file. | ||
| 5902 | |||
| 5903 | @param thd Thread | ||
| 5904 | @param delete_only If true, do not create a new index file and | ||
| 5905 | a new log file. | ||
| 5906 | |||
| 5907 | @note | ||
| 5908 | If not called from slave thread, write start event to new log | ||
| 5909 | |||
| 5910 | @retval | ||
| 5911 | 0 ok | ||
| 5912 | @retval | ||
| 5913 | 1 error | ||
| 5914 | */ | ||
| 5915 | 29142 | bool MYSQL_BIN_LOG::reset_logs(THD *thd, bool delete_only) { | |
| 5916 | 29142 | LOG_INFO linfo; | |
| 5917 | 29142 | bool error = false; | |
| 5918 | int err; | ||
| 5919 | 29142 | const char *save_name = nullptr; | |
| 5920 | 29142 | Checkable_rwlock *sid_lock = nullptr; | |
| 5921 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | DBUG_TRACE; |
| 5922 | |||
| 5923 | /* | ||
| 5924 | Flush logs for storage engines, so that the last transaction | ||
| 5925 | is persisted inside storage engines. | ||
| 5926 | */ | ||
| 5927 |
2/4✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 29142 times.
|
29142 | assert(!thd->is_log_reset()); |
| 5928 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | thd->set_log_reset(); |
| 5929 |
2/4✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 29142 times.
|
29142 | if (ha_flush_logs()) { |
| 5930 | ✗ | thd->clear_log_reset(); | |
| 5931 | ✗ | return true; | |
| 5932 | } | ||
| 5933 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | thd->clear_log_reset(); |
| 5934 | |||
| 5935 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | ha_reset_logs(thd); |
| 5936 | |||
| 5937 | /* | ||
| 5938 | We need to get both locks to be sure that no one is trying to | ||
| 5939 | write to the index log file. | ||
| 5940 | */ | ||
| 5941 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | mysql_mutex_lock(&LOCK_log); |
| 5942 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | mysql_mutex_lock(&LOCK_index); |
| 5943 | |||
| 5944 |
2/2✓ Branch 0 taken 19979 times.
✓ Branch 1 taken 9163 times.
|
29142 | if (is_relay_log) |
| 5945 | 19979 | sid_lock = previous_gtid_set_relaylog->get_sid_map()->get_sid_lock(); | |
| 5946 | else | ||
| 5947 | 9163 | sid_lock = global_sid_lock; | |
| 5948 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | sid_lock->wrlock(); |
| 5949 | |||
| 5950 | /* Save variables so that we can reopen the log */ | ||
| 5951 | 29142 | save_name = name; | |
| 5952 | 29142 | name = nullptr; // Protect against free | |
| 5953 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | close(LOG_CLOSE_TO_BE_OPENED, false /*need_lock_log=false*/, |
| 5954 | false /*need_lock_index=false*/); | ||
| 5955 | |||
| 5956 | /* | ||
| 5957 | First delete all old log files and then update the index file. | ||
| 5958 | As we first delete the log files and do not use sort of logging, | ||
| 5959 | a crash may lead to an inconsistent state where the index has | ||
| 5960 | references to non-existent files. | ||
| 5961 | |||
| 5962 | We need to invert the steps and use the purge_index_file methods | ||
| 5963 | in order to make the operation safe. | ||
| 5964 | */ | ||
| 5965 | |||
| 5966 |
3/4✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 29133 times.
|
29142 | if ((err = find_log_pos(&linfo, NullS, false /*need_lock_index=false*/)) != |
| 5967 | 0) { | ||
| 5968 | 9 | uint errcode = purge_log_get_error_code(err); | |
| 5969 |
8/16✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 9 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 9 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 9 times.
✗ Branch 15 not taken.
|
9 | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_LOCATE_OLD_BINLOG_OR_RELAY_LOG_FILES); |
| 5970 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | my_error(errcode, MYF(0)); |
| 5971 | 9 | error = true; | |
| 5972 | 9 | goto err; | |
| 5973 | } | ||
| 5974 | |||
| 5975 | for (;;) { | ||
| 5976 |
3/4✓ Branch 0 taken 45133 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 45125 times.
|
45133 | if ((error = my_delete_allow_opened(linfo.log_file_name, MYF(0))) != 0) { |
| 5977 |
3/4✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 1 times.
|
8 | if (my_errno() == ENOENT) { |
| 5978 | 21 | push_warning_printf( | |
| 5979 |
2/4✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
|
7 | current_thd, Sql_condition::SL_WARNING, ER_LOG_PURGE_NO_FILE, |
| 5980 |
2/4✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
|
7 | ER_THD(current_thd, ER_LOG_PURGE_NO_FILE), linfo.log_file_name); |
| 5981 |
8/16✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 7 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 7 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 7 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 7 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 7 times.
✗ Branch 15 not taken.
|
7 | LogErr(INFORMATION_LEVEL, ER_BINLOG_CANT_DELETE_FILE, |
| 5982 | linfo.log_file_name); | ||
| 5983 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | set_my_errno(0); |
| 5984 | 7 | error = false; | |
| 5985 | } else { | ||
| 5986 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | push_warning_printf(current_thd, Sql_condition::SL_WARNING, |
| 5987 | ER_BINLOG_PURGE_FATAL_ERR, | ||
| 5988 | "a problem with deleting %s; " | ||
| 5989 | "consider examining correspondence " | ||
| 5990 | "of your binlog index file " | ||
| 5991 | "to the actual binlog files", | ||
| 5992 | linfo.log_file_name); | ||
| 5993 |
8/16✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
|
1 | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_DELETE_FILE, linfo.log_file_name); |
| 5994 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_error(ER_BINLOG_PURGE_FATAL_ERR, MYF(0)); |
| 5995 | 1 | error = true; | |
| 5996 | 1 | goto err; | |
| 5997 | } | ||
| 5998 | } | ||
| 5999 |
3/4✓ Branch 0 taken 45132 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29132 times.
✓ Branch 3 taken 16000 times.
|
45132 | if (find_next_log(&linfo, false /*need_lock_index=false*/)) break; |
| 6000 | } | ||
| 6001 | |||
| 6002 | /* Start logging with a new file */ | ||
| 6003 |
1/2✓ Branch 0 taken 29132 times.
✗ Branch 1 not taken.
|
29132 | close(LOG_CLOSE_INDEX | LOG_CLOSE_TO_BE_OPENED, false /*need_lock_log=false*/, |
| 6004 | false /*need_lock_index=false*/); | ||
| 6005 |
3/4✓ Branch 0 taken 29132 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 29131 times.
|
29132 | if ((error = my_delete_allow_opened(index_file_name, |
| 6006 | MYF(0)))) // Reset (open will update) | ||
| 6007 | { | ||
| 6008 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
|
1 | if (my_errno() == ENOENT) { |
| 6009 | ✗ | push_warning_printf( | |
| 6010 | ✗ | current_thd, Sql_condition::SL_WARNING, ER_LOG_PURGE_NO_FILE, | |
| 6011 | ✗ | ER_THD(current_thd, ER_LOG_PURGE_NO_FILE), index_file_name); | |
| 6012 | ✗ | LogErr(INFORMATION_LEVEL, ER_BINLOG_CANT_DELETE_FILE, index_file_name); | |
| 6013 | ✗ | set_my_errno(0); | |
| 6014 | ✗ | error = false; | |
| 6015 | } else { | ||
| 6016 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | push_warning_printf(current_thd, Sql_condition::SL_WARNING, |
| 6017 | ER_BINLOG_PURGE_FATAL_ERR, | ||
| 6018 | "a problem with deleting %s; " | ||
| 6019 | "consider examining correspondence " | ||
| 6020 | "of your binlog index file " | ||
| 6021 | "to the actual binlog files", | ||
| 6022 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | index_file_name); |
| 6023 |
8/16✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
|
1 | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_DELETE_FILE, index_file_name); |
| 6024 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_error(ER_BINLOG_PURGE_FATAL_ERR, MYF(0)); |
| 6025 | 1 | error = true; | |
| 6026 | 1 | goto err; | |
| 6027 | } | ||
| 6028 | } | ||
| 6029 |
5/8✓ Branch 0 taken 29131 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 29128 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3 times.
|
29131 | DBUG_EXECUTE_IF("wait_for_kill_gtid_state_clear", { |
| 6030 | const char action[] = "now WAIT_FOR kill_gtid_state_clear"; | ||
| 6031 | assert(!debug_sync_set_action(thd, STRING_WITH_LEN(action))); | ||
| 6032 | };); | ||
| 6033 | |||
| 6034 | /* | ||
| 6035 | For relay logs we clear the gtid state associated per channel(i.e rli) | ||
| 6036 | in the purge_relay_logs() | ||
| 6037 | */ | ||
| 6038 |
2/2✓ Branch 0 taken 9158 times.
✓ Branch 1 taken 19973 times.
|
29131 | if (!is_relay_log) { |
| 6039 |
3/4✓ Branch 0 taken 9158 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 9152 times.
|
9158 | if (gtid_state->clear(thd)) { |
| 6040 | 6 | error = true; | |
| 6041 | } | ||
| 6042 | /* | ||
| 6043 | Don't clear global_sid_map because gtid_state->clear() above didn't | ||
| 6044 | touched owned_gtids GTID set. | ||
| 6045 | */ | ||
| 6046 |
4/6✓ Branch 0 taken 9152 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 9152 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9152 times.
|
9158 | error = error || gtid_state->init(); |
| 6047 | } | ||
| 6048 | |||
| 6049 |
2/2✓ Branch 0 taken 26265 times.
✓ Branch 1 taken 2866 times.
|
29131 | if (!delete_only) { |
| 6050 |
2/4✓ Branch 0 taken 26265 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26265 times.
✗ Branch 3 not taken.
|
26265 | if (!open_index_file(index_file_name, nullptr, |
| 6051 | false /*need_lock_index=false*/)) | ||
| 6052 | 26265 | error = open_binlog(save_name, nullptr, max_size, false, | |
| 6053 | false /*need_lock_index=false*/, | ||
| 6054 | false /*need_sid_lock=false*/, nullptr, | ||
| 6055 |
5/6✓ Branch 0 taken 26265 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 26264 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 26258 times.
|
26265 | thd->lex->next_binlog_file_nr) || |
| 6056 | error; | ||
| 6057 | } | ||
| 6058 | /* String has been duplicated, free old file-name */ | ||
| 6059 |
2/2✓ Branch 0 taken 2867 times.
✓ Branch 1 taken 26264 times.
|
29131 | if (name != nullptr) { |
| 6060 |
1/2✓ Branch 0 taken 26264 times.
✗ Branch 1 not taken.
|
26264 | my_free(const_cast<char *>(save_name)); |
| 6061 | 26264 | save_name = nullptr; | |
| 6062 | } | ||
| 6063 | |||
| 6064 | 2867 | err: | |
| 6065 |
2/2✓ Branch 0 taken 2878 times.
✓ Branch 1 taken 26264 times.
|
29142 | if (name == nullptr) |
| 6066 | 2878 | name = const_cast<char *>(save_name); // restore old file-name | |
| 6067 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | sid_lock->unlock(); |
| 6068 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | count_binlog_space(false); |
| 6069 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | mysql_mutex_unlock(&LOCK_index); |
| 6070 |
1/2✓ Branch 0 taken 29142 times.
✗ Branch 1 not taken.
|
29142 | mysql_mutex_unlock(&LOCK_log); |
| 6071 | 29142 | return error; | |
| 6072 | 29142 | } | |
| 6073 | |||
| 6074 | /** | ||
| 6075 | Set the name of crash safe index file. | ||
| 6076 | |||
| 6077 | @retval | ||
| 6078 | 0 ok | ||
| 6079 | @retval | ||
| 6080 | 1 error | ||
| 6081 | */ | ||
| 6082 | 79081 | int MYSQL_BIN_LOG::set_crash_safe_index_file_name(const char *base_file_name) { | |
| 6083 | 79081 | int error = 0; | |
| 6084 |
1/2✓ Branch 0 taken 79081 times.
✗ Branch 1 not taken.
|
79081 | DBUG_TRACE; |
| 6085 |
1/2✓ Branch 0 taken 79081 times.
✗ Branch 1 not taken.
|
79081 | if (fn_format(crash_safe_index_file_name, base_file_name, mysql_data_home, |
| 6086 | ".index_crash_safe", | ||
| 6087 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79081 times.
|
79081 | MYF(MY_UNPACK_FILENAME | MY_SAFE_PATH | MY_REPLACE_EXT)) == |
| 6088 | nullptr) { | ||
| 6089 | ✗ | error = 1; | |
| 6090 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_SET_TMP_INDEX_NAME); | |
| 6091 | } | ||
| 6092 | 79081 | return error; | |
| 6093 | 79081 | } | |
| 6094 | |||
| 6095 | /** | ||
| 6096 | Open a (new) crash safe index file. | ||
| 6097 | |||
| 6098 | @note | ||
| 6099 | The crash safe index file is a special file | ||
| 6100 | used for guaranteeing index file crash safe. | ||
| 6101 | @retval | ||
| 6102 | 0 ok | ||
| 6103 | @retval | ||
| 6104 | 1 error | ||
| 6105 | */ | ||
| 6106 | 102886 | int MYSQL_BIN_LOG::open_crash_safe_index_file() { | |
| 6107 | 102886 | int error = 0; | |
| 6108 | 102886 | File file = -1; | |
| 6109 | |||
| 6110 |
1/2✓ Branch 0 taken 102886 times.
✗ Branch 1 not taken.
|
102886 | DBUG_TRACE; |
| 6111 | |||
| 6112 |
1/2✓ Branch 0 taken 102886 times.
✗ Branch 1 not taken.
|
102886 | if (!my_b_inited(&crash_safe_index_file)) { |
| 6113 | 102886 | myf flags = MY_WME | MY_NABP | MY_WAIT_IF_FULL; | |
| 6114 |
2/2✓ Branch 0 taken 76583 times.
✓ Branch 1 taken 26303 times.
|
102886 | if (is_relay_log) flags = flags | MY_REPORT_WAITING_IF_FULL; |
| 6115 | |||
| 6116 |
1/2✓ Branch 0 taken 102886 times.
✗ Branch 1 not taken.
|
102886 | if ((file = my_open(crash_safe_index_file_name, O_RDWR | O_CREAT, |
| 6117 |
2/4✓ Branch 0 taken 102886 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102886 times.
|
205772 | MYF(MY_WME))) < 0 || |
| 6118 |
2/4✓ Branch 0 taken 102886 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102886 times.
|
102886 | init_io_cache(&crash_safe_index_file, file, IO_SIZE, WRITE_CACHE, 0, |
| 6119 | false, flags)) { | ||
| 6120 | ✗ | error = 1; | |
| 6121 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_OPEN_TEMPORARY_INDEX_FILE); | |
| 6122 | } | ||
| 6123 | } | ||
| 6124 | 102886 | return error; | |
| 6125 | 102886 | } | |
| 6126 | |||
| 6127 | /** | ||
| 6128 | Close the crash safe index file. | ||
| 6129 | |||
| 6130 | @note | ||
| 6131 | The crash safe file is just closed, is not deleted. | ||
| 6132 | Because it is moved to index file later on. | ||
| 6133 | @retval | ||
| 6134 | 0 ok | ||
| 6135 | @retval | ||
| 6136 | 1 error | ||
| 6137 | */ | ||
| 6138 | 102884 | int MYSQL_BIN_LOG::close_crash_safe_index_file() { | |
| 6139 | 102884 | int error = 0; | |
| 6140 | |||
| 6141 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102884 | DBUG_TRACE; |
| 6142 | |||
| 6143 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | if (my_b_inited(&crash_safe_index_file)) { |
| 6144 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | end_io_cache(&crash_safe_index_file); |
| 6145 |
1/2✓ Branch 0 taken 102885 times.
✗ Branch 1 not taken.
|
102885 | error = my_close(crash_safe_index_file.file, MYF(0)); |
| 6146 | } | ||
| 6147 | 102885 | crash_safe_index_file = IO_CACHE(); | |
| 6148 | |||
| 6149 | 102885 | return error; | |
| 6150 | 102885 | } | |
| 6151 | |||
| 6152 | /** | ||
| 6153 | Remove logs from index file. | ||
| 6154 | |||
| 6155 | - To make it crash safe, we copy the content of the index file | ||
| 6156 | from index_file_start_offset recorded in log_info to a | ||
| 6157 | crash safe index file first and then move the crash | ||
| 6158 | safe index file to the index file. | ||
| 6159 | |||
| 6160 | @param log_info Store here the found log file name and | ||
| 6161 | position to the NEXT log file name in | ||
| 6162 | the index file. | ||
| 6163 | |||
| 6164 | @param need_update_threads If we want to update the log coordinates | ||
| 6165 | of all threads. False for relay logs, | ||
| 6166 | true otherwise. | ||
| 6167 | |||
| 6168 | @retval | ||
| 6169 | 0 ok | ||
| 6170 | @retval | ||
| 6171 | LOG_INFO_IO Got IO error while reading/writing file | ||
| 6172 | */ | ||
| 6173 | 24031 | int MYSQL_BIN_LOG::remove_logs_from_index(LOG_INFO *log_info, | |
| 6174 | bool need_update_threads) { | ||
| 6175 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24031 times.
|
24031 | if (open_crash_safe_index_file()) { |
| 6176 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_TMP_INDEX, | |
| 6177 | "MYSQL_BIN_LOG::remove_logs_from_index"); | ||
| 6178 | ✗ | goto err; | |
| 6179 | } | ||
| 6180 | |||
| 6181 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24031 times.
|
24031 | if (copy_file(&index_file, &crash_safe_index_file, |
| 6182 | log_info->index_file_start_offset)) { | ||
| 6183 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_COPY_INDEX_TO_TMP, | |
| 6184 | "MYSQL_BIN_LOG::remove_logs_from_index"); | ||
| 6185 | ✗ | goto err; | |
| 6186 | } | ||
| 6187 | |||
| 6188 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24031 times.
|
24031 | if (close_crash_safe_index_file()) { |
| 6189 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_CLOSE_TMP_INDEX, | |
| 6190 | "MYSQL_BIN_LOG::remove_logs_from_index"); | ||
| 6191 | ✗ | goto err; | |
| 6192 | } | ||
| 6193 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24031 times.
|
24031 | DBUG_EXECUTE_IF("fault_injection_copy_part_file", DBUG_SUICIDE();); |
| 6194 | |||
| 6195 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24030 times.
|
24031 | if (move_crash_safe_index_file_to_index_file( |
| 6196 | false /*need_lock_index=false*/)) { | ||
| 6197 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_MOVE_TMP_TO_INDEX, | |
| 6198 | "MYSQL_BIN_LOG::remove_logs_from_index"); | ||
| 6199 | ✗ | goto err; | |
| 6200 | } | ||
| 6201 | |||
| 6202 | // now update offsets in index file for running threads | ||
| 6203 |
2/2✓ Branch 0 taken 207 times.
✓ Branch 1 taken 23823 times.
|
24030 | if (need_update_threads) |
| 6204 | 207 | adjust_linfo_offsets(log_info->index_file_start_offset); | |
| 6205 | 24030 | return 0; | |
| 6206 | |||
| 6207 | ✗ | err: | |
| 6208 | ✗ | return LOG_INFO_IO; | |
| 6209 | } | ||
| 6210 | |||
| 6211 | /** | ||
| 6212 | Remove all logs before the given log from disk and from the index file. | ||
| 6213 | |||
| 6214 | @param to_log Delete all log file name before this file. | ||
| 6215 | @param included If true, to_log is deleted too. | ||
| 6216 | @param need_lock_index Set to true, if the lock_index of the binary log | ||
| 6217 | shall be acquired, false if the called is already the owner of the lock_index. | ||
| 6218 | @param need_update_threads If we want to update the log coordinates of | ||
| 6219 | all threads. False for relay logs, true otherwise. | ||
| 6220 | @param decrease_log_space If not null, decrement this variable of | ||
| 6221 | the amount of log space freed | ||
| 6222 | @param auto_purge True if this is an automatic purge. | ||
| 6223 | |||
| 6224 | @note | ||
| 6225 | If any of the logs before the deleted one is in use, | ||
| 6226 | only purge logs up to this one. | ||
| 6227 | |||
| 6228 | @retval 0 ok | ||
| 6229 | @retval LOG_INFO_EOF to_log not found | ||
| 6230 | @retval LOG_INFO_EMFILE too many files opened | ||
| 6231 | @retval LOG_INFO_FATAL if any other than ENOENT error from | ||
| 6232 | mysql_file_stat() or mysql_file_delete() | ||
| 6233 | */ | ||
| 6234 | |||
| 6235 | 24033 | int MYSQL_BIN_LOG::purge_logs(const char *to_log, bool included, | |
| 6236 | bool need_lock_index, bool need_update_threads, | ||
| 6237 | ulonglong *decrease_log_space, bool auto_purge) { | ||
| 6238 | 24033 | int error = 0, no_of_log_files_to_purge = 0, no_of_log_files_purged = 0; | |
| 6239 | 24033 | int no_of_threads_locking_log = 0; | |
| 6240 | 24033 | bool exit_loop = false; | |
| 6241 | 24033 | LOG_INFO log_info; | |
| 6242 |
1/2✓ Branch 0 taken 24033 times.
✗ Branch 1 not taken.
|
24033 | THD *thd = current_thd; |
| 6243 |
1/2✓ Branch 0 taken 24033 times.
✗ Branch 1 not taken.
|
24033 | DBUG_TRACE; |
| 6244 |
3/8✓ Branch 0 taken 24033 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24033 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 24033 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
24033 | DBUG_PRINT("info", ("to_log= %s", to_log)); |
| 6245 | |||
| 6246 |
2/2✓ Branch 0 taken 111 times.
✓ Branch 1 taken 23922 times.
|
24033 | if (need_lock_index) |
| 6247 |
1/2✓ Branch 0 taken 111 times.
✗ Branch 1 not taken.
|
111 | mysql_mutex_lock(&LOCK_index); |
| 6248 | else | ||
| 6249 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 6250 | 24033 | if ((error = | |
| 6251 |
3/4✓ Branch 0 taken 24033 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 24031 times.
|
24033 | find_log_pos(&log_info, to_log, false /*need_lock_index=false*/))) { |
| 6252 |
8/16✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 2 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 2 times.
✗ Branch 15 not taken.
|
2 | LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CALLED_WITH_FILE_NOT_IN_INDEX, |
| 6253 | to_log); | ||
| 6254 | 2 | goto err; | |
| 6255 | } | ||
| 6256 | |||
| 6257 | 24031 | no_of_log_files_to_purge = log_info.entry_index; | |
| 6258 | |||
| 6259 |
2/4✓ Branch 0 taken 24031 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24031 times.
|
24031 | if ((error = open_purge_index_file(true))) { |
| 6260 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CANT_SYNC_INDEX_FILE); | |
| 6261 | ✗ | goto err; | |
| 6262 | } | ||
| 6263 | |||
| 6264 | /* | ||
| 6265 | File name exists in index file; delete until we find this file | ||
| 6266 | or a file that is used. | ||
| 6267 | */ | ||
| 6268 |
2/4✓ Branch 0 taken 24031 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24031 times.
|
24031 | if ((error = find_log_pos(&log_info, NullS, false /*need_lock_index=false*/))) |
| 6269 | ✗ | goto err; | |
| 6270 | |||
| 6271 |
5/6✓ Branch 0 taken 38964 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24031 times.
✓ Branch 3 taken 14933 times.
✓ Branch 4 taken 15032 times.
✓ Branch 5 taken 23932 times.
|
62995 | while ((compare_log_name(to_log, log_info.log_file_name) || |
| 6272 |
2/2✓ Branch 0 taken 99 times.
✓ Branch 1 taken 23932 times.
|
24031 | (exit_loop = included))) { |
| 6273 |
2/4✓ Branch 0 taken 15032 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15032 times.
|
15032 | if (is_active(log_info.log_file_name)) { |
| 6274 | ✗ | if (!auto_purge) | |
| 6275 | ✗ | push_warning_printf( | |
| 6276 | thd, Sql_condition::SL_WARNING, ER_WARN_PURGE_LOG_IS_ACTIVE, | ||
| 6277 | ER_THD(thd, ER_WARN_PURGE_LOG_IS_ACTIVE), log_info.log_file_name); | ||
| 6278 | ✗ | break; | |
| 6279 | } | ||
| 6280 | |||
| 6281 |
2/4✓ Branch 0 taken 15032 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15032 times.
|
15032 | if ((no_of_threads_locking_log = log_in_use(log_info.log_file_name))) { |
| 6282 | ✗ | if (!auto_purge) | |
| 6283 | ✗ | push_warning_printf(thd, Sql_condition::SL_WARNING, | |
| 6284 | ER_WARN_PURGE_LOG_IN_USE, | ||
| 6285 | ER_THD(thd, ER_WARN_PURGE_LOG_IN_USE), | ||
| 6286 | log_info.log_file_name, no_of_threads_locking_log, | ||
| 6287 | no_of_log_files_purged, no_of_log_files_to_purge); | ||
| 6288 | ✗ | break; | |
| 6289 | } | ||
| 6290 | 15032 | no_of_log_files_purged++; | |
| 6291 | |||
| 6292 |
2/4✓ Branch 0 taken 15032 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15032 times.
|
15032 | if ((error = register_purge_index_entry(log_info.log_file_name))) { |
| 6293 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CANT_COPY_TO_REGISTER_FILE, | |
| 6294 | log_info.log_file_name); | ||
| 6295 | ✗ | goto err; | |
| 6296 | } | ||
| 6297 | |||
| 6298 |
6/8✓ Branch 0 taken 15032 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15032 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 99 times.
✓ Branch 5 taken 14933 times.
✓ Branch 6 taken 99 times.
✓ Branch 7 taken 14933 times.
|
15032 | if (find_next_log(&log_info, false /*need_lock_index=false*/) || exit_loop) |
| 6299 | 99 | break; | |
| 6300 | } | ||
| 6301 | |||
| 6302 |
2/6✓ Branch 0 taken 24031 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24031 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
24031 | DBUG_EXECUTE_IF("crash_purge_before_update_index", DBUG_SUICIDE();); |
| 6303 | |||
| 6304 |
2/4✓ Branch 0 taken 24031 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24031 times.
|
24031 | if ((error = sync_purge_index_file())) { |
| 6305 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CANT_FLUSH_REGISTER_FILE); | |
| 6306 | ✗ | goto err; | |
| 6307 | } | ||
| 6308 | |||
| 6309 | /* We know how many files to delete. Update index file. */ | ||
| 6310 |
2/4✓ Branch 0 taken 24030 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24030 times.
|
24031 | if ((error = remove_logs_from_index(&log_info, need_update_threads))) { |
| 6311 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_CANT_UPDATE_INDEX_FILE); | |
| 6312 | ✗ | goto err; | |
| 6313 | } | ||
| 6314 | |||
| 6315 | // Update gtid_state->lost_gtids | ||
| 6316 |
2/2✓ Branch 0 taken 207 times.
✓ Branch 1 taken 23823 times.
|
24030 | if (!is_relay_log) { |
| 6317 |
1/2✓ Branch 0 taken 207 times.
✗ Branch 1 not taken.
|
207 | global_sid_lock->wrlock(); |
| 6318 |
1/2✓ Branch 0 taken 207 times.
✗ Branch 1 not taken.
|
207 | error = init_gtid_sets( |
| 6319 | 207 | nullptr, const_cast<Gtid_set *>(gtid_state->get_lost_gtids()), | |
| 6320 | opt_source_verify_checksum, false /*false=don't need lock*/, | ||
| 6321 | nullptr /*trx_parser*/, nullptr /*partial_trx*/); | ||
| 6322 |
1/2✓ Branch 0 taken 207 times.
✗ Branch 1 not taken.
|
207 | global_sid_lock->unlock(); |
| 6323 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 207 times.
|
207 | if (error) goto err; |
| 6324 | } | ||
| 6325 | |||
| 6326 |
2/6✓ Branch 0 taken 24031 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24031 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
24030 | DBUG_EXECUTE_IF("crash_purge_critical_after_update_index", DBUG_SUICIDE();); |
| 6327 | |||
| 6328 | 24031 | err: | |
| 6329 | |||
| 6330 | 24033 | int error_index = 0, close_error_index = 0; | |
| 6331 | /* Read each entry from purge_index_file and delete the file. */ | ||
| 6332 |
5/8✓ Branch 0 taken 24031 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 24030 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24030 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 24033 times.
|
48064 | if (!error && is_inited_purge_index_file() && |
| 6333 |
2/4✓ Branch 0 taken 24031 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24031 times.
|
24030 | (error_index = purge_index_entry(thd, decrease_log_space, |
| 6334 | false /*need_lock_index=false*/))) | ||
| 6335 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_PURGE_LOGS_FAILED_TO_PURGE_LOG); | |
| 6336 | |||
| 6337 |
1/2✓ Branch 0 taken 24033 times.
✗ Branch 1 not taken.
|
24033 | close_error_index = close_purge_index_file(); |
| 6338 | |||
| 6339 |
2/6✓ Branch 0 taken 24033 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24033 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
24033 | DBUG_EXECUTE_IF("crash_purge_non_critical_after_update_index", |
| 6340 | DBUG_SUICIDE();); | ||
| 6341 | |||
| 6342 |
1/2✓ Branch 0 taken 24033 times.
✗ Branch 1 not taken.
|
24033 | count_binlog_space(false); |
| 6343 |
3/4✓ Branch 0 taken 111 times.
✓ Branch 1 taken 23922 times.
✓ Branch 2 taken 111 times.
✗ Branch 3 not taken.
|
24033 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 6344 | |||
| 6345 | /* | ||
| 6346 | Error codes from purge logs take precedence. | ||
| 6347 | Then error codes from purging the index entry. | ||
| 6348 | Finally, error codes from closing the purge index file. | ||
| 6349 | */ | ||
| 6350 |
3/4✓ Branch 0 taken 24031 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 24031 times.
|
24033 | error = error ? error : (error_index ? error_index : close_error_index); |
| 6351 | |||
| 6352 | 24033 | return error; | |
| 6353 | 24033 | } | |
| 6354 | |||
| 6355 | 79078 | int MYSQL_BIN_LOG::set_purge_index_file_name(const char *base_file_name) { | |
| 6356 | 79078 | int error = 0; | |
| 6357 |
1/2✓ Branch 0 taken 79078 times.
✗ Branch 1 not taken.
|
79078 | DBUG_TRACE; |
| 6358 | 158156 | if (fn_format( | |
| 6359 |
1/2✓ Branch 0 taken 79078 times.
✗ Branch 1 not taken.
|
79078 | purge_index_file_name, base_file_name, mysql_data_home, ".~rec~", |
| 6360 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79078 times.
|
79078 | MYF(MY_UNPACK_FILENAME | MY_SAFE_PATH | MY_REPLACE_EXT)) == nullptr) { |
| 6361 | ✗ | error = 1; | |
| 6362 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_SET_PURGE_INDEX_FILE_NAME); | |
| 6363 | } | ||
| 6364 | 79078 | return error; | |
| 6365 | 79078 | } | |
| 6366 | |||
| 6367 | 181972 | int MYSQL_BIN_LOG::open_purge_index_file(bool destroy) { | |
| 6368 | 181972 | int error = 0; | |
| 6369 | 181972 | File file = -1; | |
| 6370 | |||
| 6371 |
1/2✓ Branch 0 taken 181972 times.
✗ Branch 1 not taken.
|
181972 | DBUG_TRACE; |
| 6372 | |||
| 6373 |
3/4✓ Branch 0 taken 102894 times.
✓ Branch 1 taken 79078 times.
✓ Branch 2 taken 102894 times.
✗ Branch 3 not taken.
|
181972 | if (destroy) close_purge_index_file(); |
| 6374 | |||
| 6375 |
1/2✓ Branch 0 taken 181972 times.
✗ Branch 1 not taken.
|
181972 | if (!my_b_inited(&purge_index_file)) { |
| 6376 | 181972 | myf flags = MY_WME | MY_NABP | MY_WAIT_IF_FULL; | |
| 6377 |
2/2✓ Branch 0 taken 129345 times.
✓ Branch 1 taken 52627 times.
|
181972 | if (is_relay_log) flags = flags | MY_REPORT_WAITING_IF_FULL; |
| 6378 | |||
| 6379 |
1/2✓ Branch 0 taken 181972 times.
✗ Branch 1 not taken.
|
181972 | if ((file = my_open(purge_index_file_name, O_RDWR | O_CREAT, MYF(MY_WME))) < |
| 6380 |
2/4✓ Branch 0 taken 181972 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 181972 times.
|
363944 | 0 || |
| 6381 |
4/6✓ Branch 0 taken 102894 times.
✓ Branch 1 taken 79078 times.
✓ Branch 2 taken 181972 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 181972 times.
|
181972 | init_io_cache(&purge_index_file, file, IO_SIZE, |
| 6382 | (destroy ? WRITE_CACHE : READ_CACHE), 0, false, flags)) { | ||
| 6383 | ✗ | error = 1; | |
| 6384 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_OPEN_REGISTER_FILE); | |
| 6385 | } | ||
| 6386 | } | ||
| 6387 | 181972 | return error; | |
| 6388 | 181972 | } | |
| 6389 | |||
| 6390 | 284862 | int MYSQL_BIN_LOG::close_purge_index_file() { | |
| 6391 | 284862 | int error = 0; | |
| 6392 | |||
| 6393 |
1/2✓ Branch 0 taken 284862 times.
✗ Branch 1 not taken.
|
284862 | DBUG_TRACE; |
| 6394 | |||
| 6395 |
2/2✓ Branch 0 taken 181967 times.
✓ Branch 1 taken 102895 times.
|
284862 | if (my_b_inited(&purge_index_file)) { |
| 6396 |
1/2✓ Branch 0 taken 181967 times.
✗ Branch 1 not taken.
|
181967 | end_io_cache(&purge_index_file); |
| 6397 |
1/2✓ Branch 0 taken 181967 times.
✗ Branch 1 not taken.
|
181967 | error = my_close(purge_index_file.file, MYF(0)); |
| 6398 | } | ||
| 6399 |
1/2✓ Branch 0 taken 284862 times.
✗ Branch 1 not taken.
|
284862 | my_delete(purge_index_file_name, MYF(0)); |
| 6400 | 284862 | new (&purge_index_file) IO_CACHE(); | |
| 6401 | |||
| 6402 | 284862 | return error; | |
| 6403 | 284862 | } | |
| 6404 | |||
| 6405 | 24033 | bool MYSQL_BIN_LOG::is_inited_purge_index_file() { | |
| 6406 |
1/2✓ Branch 0 taken 24033 times.
✗ Branch 1 not taken.
|
24033 | DBUG_TRACE; |
| 6407 | 48065 | return my_b_inited(&purge_index_file); | |
| 6408 | 24033 | } | |
| 6409 | |||
| 6410 | 102894 | int MYSQL_BIN_LOG::sync_purge_index_file() { | |
| 6411 | 102894 | int error = 0; | |
| 6412 |
1/2✓ Branch 0 taken 102894 times.
✗ Branch 1 not taken.
|
102894 | DBUG_TRACE; |
| 6413 | |||
| 6414 |
5/6✓ Branch 0 taken 102894 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 102893 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 102893 times.
|
205787 | if ((error = flush_io_cache(&purge_index_file)) || |
| 6415 |
2/4✓ Branch 0 taken 102893 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 102893 times.
|
102893 | (error = my_sync(purge_index_file.file, MYF(MY_WME)))) |
| 6416 | 1 | return error; | |
| 6417 | |||
| 6418 | 102893 | return error; | |
| 6419 | 102894 | } | |
| 6420 | |||
| 6421 | 93895 | int MYSQL_BIN_LOG::register_purge_index_entry(const char *entry) { | |
| 6422 | 93895 | int error = 0; | |
| 6423 |
1/2✓ Branch 0 taken 93895 times.
✗ Branch 1 not taken.
|
93895 | DBUG_TRACE; |
| 6424 | |||
| 6425 |
1/2✓ Branch 0 taken 93895 times.
✗ Branch 1 not taken.
|
93895 | if ((error = my_b_write(&purge_index_file, (const uchar *)entry, |
| 6426 |
2/4✓ Branch 0 taken 93895 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 93895 times.
|
187790 | strlen(entry))) || |
| 6427 |
2/4✓ Branch 0 taken 93895 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 93895 times.
|
93895 | (error = my_b_write(&purge_index_file, (const uchar *)"\n", 1))) |
| 6428 | ✗ | return error; | |
| 6429 | |||
| 6430 | 93895 | return error; | |
| 6431 | 93895 | } | |
| 6432 | |||
| 6433 | 78863 | int MYSQL_BIN_LOG::register_create_index_entry(const char *entry) { | |
| 6434 |
1/2✓ Branch 0 taken 78863 times.
✗ Branch 1 not taken.
|
78863 | DBUG_TRACE; |
| 6435 |
1/2✓ Branch 0 taken 78863 times.
✗ Branch 1 not taken.
|
157726 | return register_purge_index_entry(entry); |
| 6436 | 78863 | } | |
| 6437 | |||
| 6438 | 103110 | int MYSQL_BIN_LOG::purge_index_entry(THD *thd, ulonglong *decrease_log_space, | |
| 6439 | bool need_lock_index) { | ||
| 6440 | MY_STAT s; | ||
| 6441 | 103110 | int error = 0; | |
| 6442 | 103110 | LOG_INFO log_info; | |
| 6443 | 103111 | LOG_INFO check_log_info; | |
| 6444 | |||
| 6445 |
1/2✓ Branch 0 taken 103111 times.
✗ Branch 1 not taken.
|
103111 | DBUG_TRACE; |
| 6446 | |||
| 6447 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 103111 times.
|
103111 | assert(my_b_inited(&purge_index_file)); |
| 6448 | |||
| 6449 | 103110 | if ((error = | |
| 6450 |
2/4✓ Branch 0 taken 103110 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 103110 times.
|
103111 | reinit_io_cache(&purge_index_file, READ_CACHE, 0, false, false))) { |
| 6451 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_REINIT_REGISTER_FILE); | |
| 6452 | ✗ | goto err; | |
| 6453 | } | ||
| 6454 | |||
| 6455 | for (;;) { | ||
| 6456 | size_t length; | ||
| 6457 | |||
| 6458 |
1/2✓ Branch 0 taken 118151 times.
✗ Branch 1 not taken.
|
118150 | if ((length = my_b_gets(&purge_index_file, log_info.log_file_name, |
| 6459 |
2/2✓ Branch 0 taken 103111 times.
✓ Branch 1 taken 15040 times.
|
118151 | FN_REFLEN)) <= 1) { |
| 6460 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 103111 times.
|
103111 | if (purge_index_file.error) { |
| 6461 | ✗ | error = purge_index_file.error; | |
| 6462 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_READ_REGISTER_FILE, error); | |
| 6463 | ✗ | goto err; | |
| 6464 | } | ||
| 6465 | |||
| 6466 | /* Reached EOF */ | ||
| 6467 | 103111 | break; | |
| 6468 | } | ||
| 6469 | |||
| 6470 | /* Get rid of the trailing '\n' */ | ||
| 6471 | 15040 | log_info.log_file_name[length - 1] = 0; | |
| 6472 | |||
| 6473 |
3/4✓ Branch 0 taken 15040 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 15036 times.
|
15040 | if (!mysql_file_stat(m_key_file_log, log_info.log_file_name, &s, MYF(0))) { |
| 6474 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
4 | if (my_errno() == ENOENT) { |
| 6475 | /* | ||
| 6476 | It's not fatal if we can't stat a log file that does not exist; | ||
| 6477 | If we could not stat, we won't delete. | ||
| 6478 | */ | ||
| 6479 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (thd) { |
| 6480 | ✗ | push_warning_printf( | |
| 6481 | thd, Sql_condition::SL_WARNING, ER_LOG_PURGE_NO_FILE, | ||
| 6482 | ER_THD(thd, ER_LOG_PURGE_NO_FILE), log_info.log_file_name); | ||
| 6483 | } | ||
| 6484 |
8/16✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 4 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 4 times.
✗ Branch 15 not taken.
|
4 | LogErr(INFORMATION_LEVEL, ER_CANT_STAT_FILE, log_info.log_file_name); |
| 6485 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | set_my_errno(0); |
| 6486 | } else { | ||
| 6487 | /* | ||
| 6488 | Other than ENOENT are fatal | ||
| 6489 | */ | ||
| 6490 | ✗ | if (thd) { | |
| 6491 | ✗ | push_warning_printf(thd, Sql_condition::SL_WARNING, | |
| 6492 | ER_BINLOG_PURGE_FATAL_ERR, | ||
| 6493 | "a problem with getting info on being purged %s; " | ||
| 6494 | "consider examining correspondence " | ||
| 6495 | "of your binlog index file " | ||
| 6496 | "to the actual binlog files", | ||
| 6497 | log_info.log_file_name); | ||
| 6498 | } else { | ||
| 6499 | ✗ | LogErr(INFORMATION_LEVEL, | |
| 6500 | ER_BINLOG_CANT_DELETE_LOG_FILE_DOES_INDEX_MATCH_FILES, | ||
| 6501 | log_info.log_file_name); | ||
| 6502 | } | ||
| 6503 | ✗ | error = LOG_INFO_FATAL; | |
| 6504 | ✗ | goto err; | |
| 6505 | } | ||
| 6506 | } else { | ||
| 6507 |
2/4✓ Branch 0 taken 15036 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15036 times.
✗ Branch 3 not taken.
|
15036 | if ((error = find_log_pos(&check_log_info, log_info.log_file_name, |
| 6508 | need_lock_index))) { | ||
| 6509 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15036 times.
|
15036 | if (error != LOG_INFO_EOF) { |
| 6510 | ✗ | if (thd) { | |
| 6511 | ✗ | push_warning_printf(thd, Sql_condition::SL_WARNING, | |
| 6512 | ER_BINLOG_PURGE_FATAL_ERR, | ||
| 6513 | "a problem with deleting %s and " | ||
| 6514 | "reading the binlog index file", | ||
| 6515 | log_info.log_file_name); | ||
| 6516 | } else { | ||
| 6517 | ✗ | LogErr(INFORMATION_LEVEL, | |
| 6518 | ER_BINLOG_CANT_DELETE_FILE_AND_READ_BINLOG_INDEX, | ||
| 6519 | log_info.log_file_name); | ||
| 6520 | } | ||
| 6521 | ✗ | goto err; | |
| 6522 | } | ||
| 6523 | |||
| 6524 | 15036 | error = 0; | |
| 6525 |
1/2✓ Branch 0 taken 15036 times.
✗ Branch 1 not taken.
|
15036 | if (!need_lock_index) { |
| 6526 | /* | ||
| 6527 | This is to avoid triggering an error in NDB. | ||
| 6528 | |||
| 6529 | @todo: This is weird, what does NDB errors have to do with | ||
| 6530 | need_lock_index? Explain better or refactor /Sven | ||
| 6531 | */ | ||
| 6532 |
2/4✓ Branch 0 taken 15036 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15036 times.
✗ Branch 3 not taken.
|
15036 | ha_binlog_index_purge_file(current_thd, log_info.log_file_name); |
| 6533 | } | ||
| 6534 | |||
| 6535 |
3/8✓ Branch 0 taken 15036 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15036 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15036 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
15036 | DBUG_PRINT("info", ("purging %s", log_info.log_file_name)); |
| 6536 |
2/4✓ Branch 0 taken 15036 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15036 times.
✗ Branch 3 not taken.
|
15036 | if (!mysql_file_delete(key_file_binlog, log_info.log_file_name, |
| 6537 | MYF(0))) { | ||
| 6538 |
6/10✓ Branch 0 taken 15036 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 15035 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 times.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
|
15036 | DBUG_EXECUTE_IF("wait_in_purge_index_entry", { |
| 6539 | const char action[] = | ||
| 6540 | "now SIGNAL in_purge_index_entry WAIT_FOR go_ahead_sql"; | ||
| 6541 | assert(!debug_sync_set_action(thd, STRING_WITH_LEN(action))); | ||
| 6542 | DBUG_SET("-d,wait_in_purge_index_entry"); | ||
| 6543 | };); | ||
| 6544 | |||
| 6545 |
2/2✓ Branch 0 taken 14738 times.
✓ Branch 1 taken 298 times.
|
15036 | if (decrease_log_space) *decrease_log_space -= s.st_size; |
| 6546 | } else { | ||
| 6547 | ✗ | if (my_errno() == ENOENT) { | |
| 6548 | ✗ | if (thd) { | |
| 6549 | ✗ | push_warning_printf( | |
| 6550 | thd, Sql_condition::SL_WARNING, ER_LOG_PURGE_NO_FILE, | ||
| 6551 | ER_THD(thd, ER_LOG_PURGE_NO_FILE), log_info.log_file_name); | ||
| 6552 | } | ||
| 6553 | ✗ | LogErr(INFORMATION_LEVEL, ER_BINLOG_CANT_DELETE_FILE, | |
| 6554 | log_info.log_file_name); | ||
| 6555 | ✗ | set_my_errno(0); | |
| 6556 | } else { | ||
| 6557 | ✗ | if (thd) { | |
| 6558 | ✗ | push_warning_printf(thd, Sql_condition::SL_WARNING, | |
| 6559 | ER_BINLOG_PURGE_FATAL_ERR, | ||
| 6560 | "a problem with deleting %s; " | ||
| 6561 | "consider examining correspondence " | ||
| 6562 | "of your binlog index file " | ||
| 6563 | "to the actual binlog files", | ||
| 6564 | log_info.log_file_name); | ||
| 6565 | } else { | ||
| 6566 | ✗ | LogErr(INFORMATION_LEVEL, | |
| 6567 | ER_BINLOG_CANT_DELETE_LOG_FILE_DOES_INDEX_MATCH_FILES, | ||
| 6568 | log_info.log_file_name); | ||
| 6569 | } | ||
| 6570 | ✗ | if (my_errno() == EMFILE) { | |
| 6571 | ✗ | DBUG_PRINT("info", ("my_errno: %d, set ret = LOG_INFO_EMFILE", | |
| 6572 | my_errno())); | ||
| 6573 | ✗ | error = LOG_INFO_EMFILE; | |
| 6574 | ✗ | goto err; | |
| 6575 | } | ||
| 6576 | ✗ | error = LOG_INFO_FATAL; | |
| 6577 | ✗ | goto err; | |
| 6578 | } | ||
| 6579 | } | ||
| 6580 | } | ||
| 6581 | } | ||
| 6582 | 15040 | } | |
| 6583 | |||
| 6584 | 103111 | err: | |
| 6585 | 103111 | return error; | |
| 6586 | 103111 | } | |
| 6587 | |||
| 6588 | /** | ||
| 6589 | Count a total size of binary logs (except the active one) to the variable | ||
| 6590 | binlog_space_total. | ||
| 6591 | |||
| 6592 | @param need_lock_index If true, this function acquires LOCK_index; | ||
| 6593 | otherwise the caller should already have acquired it. | ||
| 6594 | |||
| 6595 | @retval | ||
| 6596 | 0 ok | ||
| 6597 | @retval | ||
| 6598 | LOG_INFO_FATAL if any other than ENOENT error from | ||
| 6599 | mysql_file_stat() or mysql_file_delete() | ||
| 6600 | LOG_INFO_EOF End of log-index-file found | ||
| 6601 | LOG_INFO_IO Got IO error while reading log-index-file | ||
| 6602 | */ | ||
| 6603 | |||
| 6604 | 53243 | int MYSQL_BIN_LOG::count_binlog_space(bool need_lock_index) { | |
| 6605 |
1/2✓ Branch 0 taken 53243 times.
✗ Branch 1 not taken.
|
53243 | DBUG_ENTER("count_binlog_space"); |
| 6606 |
3/4✓ Branch 0 taken 43803 times.
✓ Branch 1 taken 9440 times.
✓ Branch 2 taken 43803 times.
✗ Branch 3 not taken.
|
53243 | if (is_relay_log) DBUG_RETURN(0); |
| 6607 | |||
| 6608 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9440 times.
|
9440 | if (need_lock_index) |
| 6609 | ✗ | mysql_mutex_lock(&LOCK_index); | |
| 6610 | else | ||
| 6611 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 6612 | |||
| 6613 | int error; | ||
| 6614 | 9440 | LOG_INFO log_info; | |
| 6615 | 9440 | binlog_space_total = 0; | |
| 6616 |
3/4✓ Branch 0 taken 9440 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 9433 times.
|
9440 | if ((error = find_log_pos(&log_info, NullS, false /*need_lock_index=false*/))) |
| 6617 | 7 | goto done; | |
| 6618 | |||
| 6619 | MY_STAT stat_area; | ||
| 6620 |
3/4✓ Branch 0 taken 10123 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 690 times.
✓ Branch 3 taken 9433 times.
|
10123 | while (!(is_active(log_info.log_file_name))) { |
| 6621 |
2/4✓ Branch 0 taken 690 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 690 times.
|
690 | if (!mysql_file_stat(m_key_file_log, log_info.log_file_name, &stat_area, |
| 6622 | MYF(0))) { | ||
| 6623 | ✗ | if (my_errno() == ENOENT) { | |
| 6624 | /* | ||
| 6625 | It's not fatal if we can't stat a log file that does not exist. | ||
| 6626 | */ | ||
| 6627 | ✗ | set_my_errno(0); | |
| 6628 | } else { | ||
| 6629 | ✗ | error = LOG_INFO_FATAL; | |
| 6630 | ✗ | goto done; | |
| 6631 | } | ||
| 6632 | } else { | ||
| 6633 | 690 | binlog_space_total += stat_area.st_size; | |
| 6634 | } | ||
| 6635 |
2/4✓ Branch 0 taken 690 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 690 times.
|
690 | if (find_next_log(&log_info, false /*need_lock_index=false*/)) break; |
| 6636 | } | ||
| 6637 | |||
| 6638 | 9433 | error = 0; | |
| 6639 | |||
| 6640 | 9440 | done: | |
| 6641 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 9440 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
9440 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 6642 |
1/2✓ Branch 0 taken 9440 times.
✗ Branch 1 not taken.
|
9440 | DBUG_RETURN(error); |
| 6643 | } | ||
| 6644 | |||
| 6645 | /** | ||
| 6646 | Purge old logs so that we have a total size lower than binlog_space_limit. | ||
| 6647 | |||
| 6648 | @param need_lock_index If true, this function acquires LOCK_index; | ||
| 6649 | otherwise the caller should already have acquired it. | ||
| 6650 | |||
| 6651 | @note | ||
| 6652 | If any of the logs before the deleted one is in use, | ||
| 6653 | only purge logs up to this one. | ||
| 6654 | |||
| 6655 | @retval | ||
| 6656 | 0 ok | ||
| 6657 | @retval | ||
| 6658 | LOG_INFO_FATAL if any other than ENOENT error from | ||
| 6659 | mysql_file_stat() or mysql_file_delete() | ||
| 6660 | LOG_INFO_EOF End of log-index-file found | ||
| 6661 | LOG_INFO_IO Got IO error while reading log-index-file | ||
| 6662 | */ | ||
| 6663 | |||
| 6664 | 68 | int MYSQL_BIN_LOG::purge_logs_by_size(bool need_lock_index) { | |
| 6665 |
1/2✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
|
68 | DBUG_ENTER("purge_logs_by_size"); |
| 6666 | |||
| 6667 |
2/6✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 68 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
68 | if (is_relay_log || !binlog_space_limit) DBUG_RETURN(0); |
| 6668 | |||
| 6669 |
1/2✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
|
68 | if (need_lock_index) |
| 6670 |
1/2✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
|
68 | mysql_mutex_lock(&LOCK_index); |
| 6671 | else | ||
| 6672 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 6673 | |||
| 6674 | 68 | int error = 0; | |
| 6675 | 68 | LOG_INFO log_info; | |
| 6676 | 68 | const auto binlog_pos = m_binlog_file->position(); | |
| 6677 |
1/2✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
|
68 | count_binlog_space(false); |
| 6678 | |||
| 6679 |
2/2✓ Branch 0 taken 62 times.
✓ Branch 1 taken 6 times.
|
68 | if (!binlog_space_total || |
| 6680 |
2/2✓ Branch 0 taken 35 times.
✓ Branch 1 taken 27 times.
|
62 | binlog_space_total + binlog_pos <= binlog_space_limit) |
| 6681 | 41 | goto done; | |
| 6682 | |||
| 6683 |
2/4✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 27 times.
|
27 | if ((error = find_log_pos(&log_info, NullS, false /*need_lock_index=false*/))) |
| 6684 | ✗ | goto done; | |
| 6685 | |||
| 6686 | MY_STAT stat_area; | ||
| 6687 | char to_log[FN_REFLEN]; | ||
| 6688 | 27 | to_log[0] = 0; | |
| 6689 |
3/4✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 51 times.
✓ Branch 3 taken 9 times.
|
60 | while (!is_active(log_info.log_file_name)) { |
| 6690 |
2/4✓ Branch 0 taken 51 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 51 times.
|
51 | if (!mysql_file_stat(m_key_file_log, log_info.log_file_name, &stat_area, |
| 6691 | MYF(0))) { | ||
| 6692 | ✗ | if (my_errno() == ENOENT) { | |
| 6693 | /* | ||
| 6694 | It's not fatal if we can't stat a log file that does not exist. | ||
| 6695 | */ | ||
| 6696 | ✗ | set_my_errno(0); | |
| 6697 | } else { | ||
| 6698 | /* | ||
| 6699 | Other than ENOENT are fatal | ||
| 6700 | */ | ||
| 6701 | ✗ | THD *thd = current_thd; | |
| 6702 | ✗ | if (thd) { | |
| 6703 | ✗ | push_warning_printf(thd, Sql_condition::SL_WARNING, | |
| 6704 | ER_BINLOG_PURGE_FATAL_ERR, | ||
| 6705 | "a problem with getting info on being purged %s; " | ||
| 6706 | "consider examining correspondence " | ||
| 6707 | "of your binlog index file " | ||
| 6708 | "to the actual binlog files", | ||
| 6709 | log_info.log_file_name); | ||
| 6710 | } else { | ||
| 6711 | ✗ | LogErr(INFORMATION_LEVEL, ER_CANT_STAT_FILE, log_info.log_file_name); | |
| 6712 | } | ||
| 6713 | ✗ | error = LOG_INFO_FATAL; | |
| 6714 | ✗ | goto done; | |
| 6715 | } | ||
| 6716 | } | ||
| 6717 | /* check if a total size of binary logs is bigger than binlog_space_limit | ||
| 6718 | if yes check if it is in use, if not in use then add | ||
| 6719 | it in the list of binary log files to be purged. | ||
| 6720 | */ | ||
| 6721 |
2/2✓ Branch 0 taken 33 times.
✓ Branch 1 taken 18 times.
|
51 | else if (binlog_space_total + binlog_pos > binlog_space_limit) { |
| 6722 |
2/4✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33 times.
|
33 | if ((log_in_use(log_info.log_file_name))) break; |
| 6723 |
3/8✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 33 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
33 | DBUG_PRINT("info", ("purge_logs_by_size binlog_space_total=%llu " |
| 6724 | "binlog_pos=%llu sum=%llu\n", | ||
| 6725 | binlog_space_total, binlog_pos, | ||
| 6726 | binlog_space_total + binlog_pos)); | ||
| 6727 |
1/2✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
|
33 | if (binlog_space_total >= (ulonglong)stat_area.st_size) |
| 6728 | 33 | binlog_space_total -= stat_area.st_size; | |
| 6729 | else | ||
| 6730 | ✗ | break; | |
| 6731 |
1/2✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
|
33 | strmake(to_log, log_info.log_file_name, |
| 6732 | sizeof(log_info.log_file_name) - 1); | ||
| 6733 | } else | ||
| 6734 | 18 | break; | |
| 6735 |
2/4✓ Branch 0 taken 33 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 33 times.
|
33 | if (find_next_log(&log_info, false /*need_lock_index=false*/)) break; |
| 6736 | } | ||
| 6737 | |||
| 6738 |
2/4✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 27 times.
✗ Branch 3 not taken.
|
27 | error = (to_log[0] ? purge_logs(to_log, true, false /*need_lock_index=false*/, |
| 6739 | true /*need_update_threads=true*/, NULL, true) | ||
| 6740 | : 0); | ||
| 6741 | |||
| 6742 | 68 | done: | |
| 6743 |
2/4✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 68 times.
✗ Branch 3 not taken.
|
68 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 6744 |
1/2✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
|
68 | DBUG_RETURN(error); |
| 6745 | } | ||
| 6746 | |||
| 6747 | /** | ||
| 6748 | Remove all logs before the given file date from disk and from the | ||
| 6749 | index file. | ||
| 6750 | |||
| 6751 | @param purge_time Delete all log files before given date. | ||
| 6752 | @param auto_purge True if this is an automatic purge. | ||
| 6753 | |||
| 6754 | @note | ||
| 6755 | If any of the logs before the deleted one is in use, | ||
| 6756 | only purge logs up to this one. | ||
| 6757 | |||
| 6758 | @retval | ||
| 6759 | 0 ok | ||
| 6760 | @retval | ||
| 6761 | LOG_INFO_PURGE_NO_ROTATE Binary file that can't be rotated | ||
| 6762 | LOG_INFO_FATAL if any other than ENOENT error from | ||
| 6763 | mysql_file_stat() or mysql_file_delete() | ||
| 6764 | */ | ||
| 6765 | |||
| 6766 | 15947 | int MYSQL_BIN_LOG::purge_logs_before_date(time_t purge_time, bool auto_purge) { | |
| 6767 | int error; | ||
| 6768 | 15947 | int no_of_threads_locking_log = 0, no_of_log_files_purged = 0; | |
| 6769 | 15947 | bool log_is_active = false, log_is_in_use = false; | |
| 6770 | char to_log[FN_REFLEN], copy_log_in_use[FN_REFLEN]; | ||
| 6771 | 15947 | LOG_INFO log_info; | |
| 6772 | MY_STAT stat_area; | ||
| 6773 |
1/2✓ Branch 0 taken 15947 times.
✗ Branch 1 not taken.
|
15947 | THD *thd = current_thd; |
| 6774 | |||
| 6775 |
1/2✓ Branch 0 taken 15947 times.
✗ Branch 1 not taken.
|
15947 | DBUG_TRACE; |
| 6776 | |||
| 6777 |
1/2✓ Branch 0 taken 15947 times.
✗ Branch 1 not taken.
|
15947 | mysql_mutex_lock(&LOCK_index); |
| 6778 | 15947 | to_log[0] = 0; | |
| 6779 | |||
| 6780 |
2/4✓ Branch 0 taken 15947 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15947 times.
|
15947 | if ((error = find_log_pos(&log_info, NullS, false /*need_lock_index=false*/))) |
| 6781 | ✗ | goto err; | |
| 6782 | |||
| 6783 |
3/4✓ Branch 0 taken 16086 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11837 times.
✓ Branch 3 taken 4249 times.
|
16086 | while (!(log_is_active = is_active(log_info.log_file_name))) { |
| 6784 |
2/4✓ Branch 0 taken 11837 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11837 times.
|
11837 | if (!mysql_file_stat(m_key_file_log, log_info.log_file_name, &stat_area, |
| 6785 | MYF(0))) { | ||
| 6786 | ✗ | if (my_errno() == ENOENT) { | |
| 6787 | /* | ||
| 6788 | It's not fatal if we can't stat a log file that does not exist. | ||
| 6789 | */ | ||
| 6790 | ✗ | set_my_errno(0); | |
| 6791 | } else { | ||
| 6792 | /* | ||
| 6793 | Other than ENOENT are fatal | ||
| 6794 | */ | ||
| 6795 | ✗ | if (thd) { | |
| 6796 | ✗ | push_warning_printf(thd, Sql_condition::SL_WARNING, | |
| 6797 | ER_BINLOG_PURGE_FATAL_ERR, | ||
| 6798 | "a problem with getting info on being purged %s; " | ||
| 6799 | "consider examining correspondence " | ||
| 6800 | "of your binlog index file " | ||
| 6801 | "to the actual binlog files", | ||
| 6802 | log_info.log_file_name); | ||
| 6803 | } else { | ||
| 6804 | ✗ | LogErr(INFORMATION_LEVEL, ER_BINLOG_FAILED_TO_DELETE_LOG_FILE, | |
| 6805 | log_info.log_file_name); | ||
| 6806 | } | ||
| 6807 | ✗ | error = LOG_INFO_FATAL; | |
| 6808 | ✗ | goto err; | |
| 6809 | } | ||
| 6810 | } | ||
| 6811 | /* check if the binary log file is older than the purge_time | ||
| 6812 | if yes check if it is in use, if not in use then add | ||
| 6813 | it in the list of binary log files to be purged. | ||
| 6814 | */ | ||
| 6815 |
2/2✓ Branch 0 taken 139 times.
✓ Branch 1 taken 11698 times.
|
11837 | else if (stat_area.st_mtime < purge_time) { |
| 6816 |
2/4✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 139 times.
|
139 | if ((no_of_threads_locking_log = log_in_use(log_info.log_file_name))) { |
| 6817 | ✗ | if (!auto_purge) { | |
| 6818 | ✗ | log_is_in_use = true; | |
| 6819 | ✗ | strcpy(copy_log_in_use, log_info.log_file_name); | |
| 6820 | } | ||
| 6821 | ✗ | break; | |
| 6822 | } | ||
| 6823 |
1/2✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
|
139 | strmake(to_log, log_info.log_file_name, |
| 6824 | sizeof(log_info.log_file_name) - 1); | ||
| 6825 | 139 | no_of_log_files_purged++; | |
| 6826 | } else | ||
| 6827 | 11698 | break; | |
| 6828 |
2/4✓ Branch 0 taken 139 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 139 times.
|
139 | if (find_next_log(&log_info, false /*need_lock_index=false*/)) break; |
| 6829 | } | ||
| 6830 | |||
| 6831 |
2/2✓ Branch 0 taken 4249 times.
✓ Branch 1 taken 11698 times.
|
15947 | if (log_is_active) { |
| 6832 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 4235 times.
|
4249 | if (!auto_purge) |
| 6833 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | push_warning_printf( |
| 6834 | thd, Sql_condition::SL_WARNING, ER_WARN_PURGE_LOG_IS_ACTIVE, | ||
| 6835 | ER_THD(thd, ER_WARN_PURGE_LOG_IS_ACTIVE), log_info.log_file_name); | ||
| 6836 | } | ||
| 6837 | |||
| 6838 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15947 times.
|
15947 | if (log_is_in_use) { |
| 6839 | ✗ | int no_of_log_files_to_purge = no_of_log_files_purged + 1; | |
| 6840 | ✗ | while (strcmp(log_file_name, log_info.log_file_name)) { | |
| 6841 | ✗ | if (mysql_file_stat(m_key_file_log, log_info.log_file_name, &stat_area, | |
| 6842 | MYF(0))) { | ||
| 6843 | ✗ | if (stat_area.st_mtime < purge_time) | |
| 6844 | ✗ | no_of_log_files_to_purge++; | |
| 6845 | else | ||
| 6846 | ✗ | break; | |
| 6847 | } | ||
| 6848 | ✗ | if (find_next_log(&log_info, false /*need_lock_index=false*/)) { | |
| 6849 | ✗ | no_of_log_files_to_purge++; | |
| 6850 | ✗ | break; | |
| 6851 | } | ||
| 6852 | } | ||
| 6853 | |||
| 6854 | ✗ | push_warning_printf(thd, Sql_condition::SL_WARNING, | |
| 6855 | ER_WARN_PURGE_LOG_IN_USE, | ||
| 6856 | ER_THD(thd, ER_WARN_PURGE_LOG_IN_USE), copy_log_in_use, | ||
| 6857 | no_of_threads_locking_log, no_of_log_files_purged, | ||
| 6858 | no_of_log_files_to_purge); | ||
| 6859 | } | ||
| 6860 | |||
| 6861 |
3/4✓ Branch 0 taken 71 times.
✓ Branch 1 taken 15876 times.
✓ Branch 2 taken 71 times.
✗ Branch 3 not taken.
|
15947 | error = (to_log[0] ? purge_logs(to_log, true, false /*need_lock_index=false*/, |
| 6862 | true /*need_update_threads=true*/, | ||
| 6863 | (ulonglong *)nullptr, auto_purge) | ||
| 6864 | : 0); | ||
| 6865 | |||
| 6866 | 15947 | err: | |
| 6867 |
1/2✓ Branch 0 taken 15947 times.
✗ Branch 1 not taken.
|
15947 | mysql_mutex_unlock(&LOCK_index); |
| 6868 | 15947 | return error; | |
| 6869 | 15947 | } | |
| 6870 | |||
| 6871 | /** | ||
| 6872 | Create a new log file name. | ||
| 6873 | |||
| 6874 | @param[out] buf Buffer allocated with at least FN_REFLEN bytes where | ||
| 6875 | new name is stored. | ||
| 6876 | @param log_ident Identity of the binary/relay log. | ||
| 6877 | |||
| 6878 | @note | ||
| 6879 | If file name will be longer then FN_REFLEN it will be truncated | ||
| 6880 | */ | ||
| 6881 | |||
| 6882 | 16631 | void MYSQL_BIN_LOG::make_log_name(char *buf, const char *log_ident) { | |
| 6883 | 16631 | size_t dir_len = dirname_length(log_file_name); | |
| 6884 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16631 times.
|
16631 | if (dir_len >= FN_REFLEN) dir_len = FN_REFLEN - 1; |
| 6885 | 16631 | my_stpnmov(buf, log_file_name, dir_len); | |
| 6886 | 16631 | strmake(buf + dir_len, log_ident, FN_REFLEN - dir_len - 1); | |
| 6887 | 16631 | } | |
| 6888 | |||
| 6889 | /** | ||
| 6890 | Check if we are writing/reading to the given log file. | ||
| 6891 | */ | ||
| 6892 | |||
| 6893 | 4011746 | bool MYSQL_BIN_LOG::is_active(const char *log_file_name_arg) { | |
| 6894 | 4011746 | return !compare_log_name(log_file_name, log_file_name_arg); | |
| 6895 | } | ||
| 6896 | |||
| 6897 | 2039489 | void MYSQL_BIN_LOG::inc_prep_xids(THD *thd) { | |
| 6898 |
1/2✓ Branch 0 taken 2039489 times.
✗ Branch 1 not taken.
|
2039489 | DBUG_TRACE; |
| 6899 | #ifndef NDEBUG | ||
| 6900 | 2039489 | int result = ++m_atomic_prep_xids; | |
| 6901 |
5/8✓ Branch 0 taken 2039489 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2039489 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 82 times.
✓ Branch 5 taken 2039407 times.
✓ Branch 6 taken 82 times.
✗ Branch 7 not taken.
|
2039489 | DBUG_PRINT("debug", ("m_atomic_prep_xids: %d", result)); |
| 6902 | #else | ||
| 6903 | m_atomic_prep_xids++; | ||
| 6904 | #endif | ||
| 6905 | 2039489 | thd->get_transaction()->m_flags.xid_written = true; | |
| 6906 | 2039489 | } | |
| 6907 | |||
| 6908 | 2039360 | void MYSQL_BIN_LOG::dec_prep_xids(THD *thd) { | |
| 6909 |
1/2✓ Branch 0 taken 2039360 times.
✗ Branch 1 not taken.
|
2039360 | DBUG_TRACE; |
| 6910 | 2039360 | int32 result = --m_atomic_prep_xids; | |
| 6911 |
5/8✓ Branch 0 taken 2039360 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2039360 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 80 times.
✓ Branch 5 taken 2039280 times.
✓ Branch 6 taken 80 times.
✗ Branch 7 not taken.
|
2039360 | DBUG_PRINT("debug", ("m_atomic_prep_xids: %d", result)); |
| 6912 | 2039360 | thd->get_transaction()->m_flags.xid_written = false; | |
| 6913 |
2/2✓ Branch 0 taken 1914393 times.
✓ Branch 1 taken 124967 times.
|
2039360 | if (result == 0) { |
| 6914 |
1/2✓ Branch 0 taken 1914393 times.
✗ Branch 1 not taken.
|
1914393 | mysql_mutex_lock(&LOCK_xids); |
| 6915 |
1/2✓ Branch 0 taken 1914393 times.
✗ Branch 1 not taken.
|
1914393 | mysql_cond_signal(&m_prep_xids_cond); |
| 6916 |
1/2✓ Branch 0 taken 1914393 times.
✗ Branch 1 not taken.
|
1914393 | mysql_mutex_unlock(&LOCK_xids); |
| 6917 | } | ||
| 6918 | 2039360 | } | |
| 6919 | |||
| 6920 | /* | ||
| 6921 | Wrappers around new_file_impl to avoid using argument | ||
| 6922 | to control locking. The argument 1) less readable 2) breaks | ||
| 6923 | incapsulation 3) allows external access to the class without | ||
| 6924 | a lock (which is not possible with private new_file_without_locking | ||
| 6925 | method). | ||
| 6926 | |||
| 6927 | @retval | ||
| 6928 | nonzero - error | ||
| 6929 | |||
| 6930 | */ | ||
| 6931 | |||
| 6932 | ✗ | int MYSQL_BIN_LOG::new_file( | |
| 6933 | Format_description_log_event *extra_description_event) { | ||
| 6934 | ✗ | return new_file_impl(true /*need_lock_log=true*/, extra_description_event); | |
| 6935 | } | ||
| 6936 | |||
| 6937 | /* | ||
| 6938 | @retval | ||
| 6939 | nonzero - error | ||
| 6940 | */ | ||
| 6941 | 31818 | int MYSQL_BIN_LOG::new_file_without_locking( | |
| 6942 | Format_description_log_event *extra_description_event) { | ||
| 6943 | 31818 | return new_file_impl(false /*need_lock_log=false*/, extra_description_event); | |
| 6944 | } | ||
| 6945 | |||
| 6946 | /** | ||
| 6947 | Start writing to a new log file or reopen the old file. | ||
| 6948 | |||
| 6949 | @param need_lock_log If true, this function acquires LOCK_log; | ||
| 6950 | otherwise the caller should already have acquired it. | ||
| 6951 | |||
| 6952 | @param extra_description_event The master's FDE to be written by the I/O | ||
| 6953 | thread while creating a new relay log file. This should be NULL for | ||
| 6954 | binary log files. | ||
| 6955 | |||
| 6956 | @retval 0 success | ||
| 6957 | @retval nonzero - error | ||
| 6958 | |||
| 6959 | @note The new file name is stored last in the index file | ||
| 6960 | */ | ||
| 6961 | 31818 | int MYSQL_BIN_LOG::new_file_impl( | |
| 6962 | bool need_lock_log, Format_description_log_event *extra_description_event) { | ||
| 6963 | 31818 | int error = 0; | |
| 6964 | 31818 | bool close_on_error = false; | |
| 6965 | 31818 | char new_name[FN_REFLEN], *new_name_ptr = nullptr, *old_name, *file_to_open; | |
| 6966 | 31818 | const size_t ERR_CLOSE_MSG_LEN = 1024; | |
| 6967 | char close_on_error_msg[ERR_CLOSE_MSG_LEN]; | ||
| 6968 | 31818 | memset(close_on_error_msg, 0, sizeof close_on_error_msg); | |
| 6969 | |||
| 6970 |
1/2✓ Branch 0 taken 31818 times.
✗ Branch 1 not taken.
|
31818 | DBUG_TRACE; |
| 6971 |
2/2✓ Branch 0 taken 29 times.
✓ Branch 1 taken 31789 times.
|
31818 | if (!is_open()) { |
| 6972 |
3/8✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 29 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
29 | DBUG_PRINT("info", ("log is closed")); |
| 6973 | 29 | return error; | |
| 6974 | } | ||
| 6975 | |||
| 6976 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31789 times.
|
31789 | if (need_lock_log) |
| 6977 | ✗ | mysql_mutex_lock(&LOCK_log); | |
| 6978 | else | ||
| 6979 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 6980 |
6/10✓ Branch 0 taken 31789 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 31780 times.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 9 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✗ Branch 9 not taken.
|
31789 | DBUG_EXECUTE_IF("semi_sync_3-way_deadlock", |
| 6981 | DEBUG_SYNC(current_thd, "before_rotate_binlog");); | ||
| 6982 |
1/2✓ Branch 0 taken 31789 times.
✗ Branch 1 not taken.
|
31789 | mysql_mutex_lock(&LOCK_xids); |
| 6983 | /* | ||
| 6984 | We need to ensure that the number of prepared XIDs are 0. | ||
| 6985 | |||
| 6986 | If m_atomic_prep_xids is not zero: | ||
| 6987 | - We wait for storage engine commit, hence decrease m_atomic_prep_xids | ||
| 6988 | - We keep the LOCK_log to block new transactions from being | ||
| 6989 | written to the binary log. | ||
| 6990 | */ | ||
| 6991 |
2/2✓ Branch 0 taken 1302 times.
✓ Branch 1 taken 31789 times.
|
33091 | while (get_prep_xids() > 0) { |
| 6992 |
1/2✓ Branch 0 taken 1302 times.
✗ Branch 1 not taken.
|
1302 | mysql_cond_wait(&m_prep_xids_cond, &LOCK_xids); |
| 6993 | } | ||
| 6994 |
1/2✓ Branch 0 taken 31789 times.
✗ Branch 1 not taken.
|
31789 | mysql_mutex_unlock(&LOCK_xids); |
| 6995 | |||
| 6996 |
1/2✓ Branch 0 taken 31789 times.
✗ Branch 1 not taken.
|
31789 | mysql_mutex_lock(&LOCK_index); |
| 6997 | |||
| 6998 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 6999 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 7000 | |||
| 7001 |
3/6✓ Branch 0 taken 31789 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31789 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 31789 times.
|
63578 | if (DBUG_EVALUATE_IF("expire_logs_always", 0, 1) && |
| 7002 |
2/4✓ Branch 0 taken 31789 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 31789 times.
|
31789 | (error = ha_flush_logs())) { |
| 7003 | ✗ | goto end; | |
| 7004 | } | ||
| 7005 | |||
| 7006 |
2/2✓ Branch 0 taken 7977 times.
✓ Branch 1 taken 23812 times.
|
31789 | if (!is_relay_log) { |
| 7007 | /* Save set of GTIDs of the last binlog into table on binlog rotation */ | ||
| 7008 |
3/4✓ Branch 0 taken 7977 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 7974 times.
|
7977 | if ((error = gtid_state->save_gtids_of_last_binlog_into_table())) { |
| 7009 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | if (error == ER_RPL_GTID_TABLE_CANNOT_OPEN) { |
| 7010 | 3 | close_on_error = | |
| 7011 | 3 | m_binlog_file->get_real_file_size() >= | |
| 7012 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
6 | static_cast<my_off_t>(max_size) || |
| 7013 |
2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
|
3 | DBUG_EVALUATE_IF("simulate_max_binlog_size", true, false); |
| 7014 | |||
| 7015 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | if (!close_on_error) { |
| 7016 |
8/16✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
|
3 | LogErr(ERROR_LEVEL, ER_BINLOG_UNABLE_TO_ROTATE_GTID_TABLE_READONLY, |
| 7017 | "Current binlog file was flushed to disk and will be kept in " | ||
| 7018 | "use."); | ||
| 7019 | } else { | ||
| 7020 | ✗ | snprintf(close_on_error_msg, sizeof close_on_error_msg, | |
| 7021 | ✗ | ER_THD(current_thd, ER_RPL_GTID_TABLE_CANNOT_OPEN), "mysql", | |
| 7022 | "gtid_executed"); | ||
| 7023 | |||
| 7024 | ✗ | if (binlog_error_action != ABORT_SERVER) | |
| 7025 | ✗ | LogErr(WARNING_LEVEL, | |
| 7026 | ER_BINLOG_UNABLE_TO_ROTATE_GTID_TABLE_READONLY, | ||
| 7027 | "Binary logging going to be disabled."); | ||
| 7028 | } | ||
| 7029 | |||
| 7030 |
2/6✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
3 | DBUG_EXECUTE_IF("gtid_executed_readonly", |
| 7031 | { DBUG_SET("-d,gtid_executed_readonly"); }); | ||
| 7032 |
2/6✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
3 | DBUG_EXECUTE_IF("simulate_max_binlog_size", |
| 7033 | { DBUG_SET("-d,simulate_max_binlog_size"); }); | ||
| 7034 | } else { | ||
| 7035 | ✗ | close_on_error = true; | |
| 7036 | ✗ | snprintf(close_on_error_msg, sizeof close_on_error_msg, "%s", | |
| 7037 | ✗ | ER_THD(current_thd, ER_OOM_SAVE_GTIDS)); | |
| 7038 | } | ||
| 7039 | 3 | goto end; | |
| 7040 | } | ||
| 7041 | } | ||
| 7042 | |||
| 7043 | /* | ||
| 7044 | If user hasn't specified an extension, generate a new log name | ||
| 7045 | We have to do this here and not in open as we want to store the | ||
| 7046 | new file name in the current binary log file. | ||
| 7047 | */ | ||
| 7048 | 31786 | new_name_ptr = new_name; | |
| 7049 |
3/4✓ Branch 0 taken 31785 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 31770 times.
|
31786 | if ((error = generate_new_name(new_name, name))) { |
| 7050 | // Use the old name if generation of new name fails. | ||
| 7051 | 15 | strcpy(new_name, name); | |
| 7052 | 15 | close_on_error = true; | |
| 7053 | 45 | snprintf(close_on_error_msg, sizeof close_on_error_msg, | |
| 7054 |
2/4✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
|
15 | ER_THD(current_thd, ER_NO_UNIQUE_LOGFILE), name); |
| 7055 |
1/2✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
|
15 | if (strlen(close_on_error_msg)) { |
| 7056 | 15 | close_on_error_msg[strlen(close_on_error_msg) - 1] = '\0'; | |
| 7057 | } | ||
| 7058 | 15 | goto end; | |
| 7059 | } | ||
| 7060 | |||
| 7061 | /* | ||
| 7062 | Make sure that the log_file is initialized before writing | ||
| 7063 | Rotate_log_event into it. | ||
| 7064 | */ | ||
| 7065 |
2/2✓ Branch 0 taken 31770 times.
✓ Branch 1 taken 1 times.
|
31770 | if (m_binlog_file->is_open()) { |
| 7066 | /* | ||
| 7067 | We log the whole file name for log file as the user may decide | ||
| 7068 | to change base names at some point. | ||
| 7069 | */ | ||
| 7070 |
1/2✓ Branch 0 taken 31770 times.
✗ Branch 1 not taken.
|
31770 | Rotate_log_event r(new_name + dirname_length(new_name), 0, LOG_EVENT_OFFSET, |
| 7071 |
3/4✓ Branch 0 taken 23811 times.
✓ Branch 1 taken 7959 times.
✓ Branch 2 taken 31770 times.
✗ Branch 3 not taken.
|
63540 | is_relay_log ? Rotate_log_event::RELAY_LOG : 0); |
| 7072 | |||
| 7073 |
3/4✓ Branch 0 taken 31770 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 31765 times.
|
31770 | if (DBUG_EVALUATE_IF("fault_injection_new_file_rotate_event", (error = 1), |
| 7074 |
4/4✓ Branch 0 taken 31765 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 31765 times.
|
63535 | false) || |
| 7075 |
2/4✓ Branch 0 taken 31765 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 31765 times.
|
31765 | (error = write_event_to_binlog(&r))) { |
| 7076 | char errbuf[MYSYS_STRERROR_SIZE]; | ||
| 7077 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
5 | DBUG_EXECUTE_IF("fault_injection_new_file_rotate_event", errno = 2;); |
| 7078 | 5 | close_on_error = true; | |
| 7079 | 20 | snprintf(close_on_error_msg, sizeof close_on_error_msg, | |
| 7080 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
5 | ER_THD(current_thd, ER_ERROR_ON_WRITE), name, errno, |
| 7081 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | my_strerror(errbuf, sizeof(errbuf), errno)); |
| 7082 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
5 | my_printf_error(ER_ERROR_ON_WRITE, ER_THD(current_thd, ER_ERROR_ON_WRITE), |
| 7083 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | MYF(ME_FATALERROR), name, errno, |
| 7084 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | my_strerror(errbuf, sizeof(errbuf), errno)); |
| 7085 | 5 | goto end; | |
| 7086 | } | ||
| 7087 | |||
| 7088 |
2/4✓ Branch 0 taken 31764 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 31764 times.
|
31765 | if ((error = m_binlog_file->flush())) { |
| 7089 | ✗ | close_on_error = true; | |
| 7090 | ✗ | snprintf(close_on_error_msg, sizeof close_on_error_msg, "%s", | |
| 7091 | "Either disk is full or file system is read only"); | ||
| 7092 | ✗ | goto end; | |
| 7093 | } | ||
| 7094 |
2/2✓ Branch 0 taken 31764 times.
✓ Branch 1 taken 5 times.
|
31769 | } |
| 7095 | |||
| 7096 |
3/6✓ Branch 0 taken 31765 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31765 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 31766 times.
✗ Branch 5 not taken.
|
31765 | DEBUG_SYNC(current_thd, "after_rotate_event_appended"); |
| 7097 | |||
| 7098 | 31766 | old_name = name; | |
| 7099 | 31766 | name = nullptr; // Don't free name | |
| 7100 |
1/2✓ Branch 0 taken 31766 times.
✗ Branch 1 not taken.
|
31766 | close(LOG_CLOSE_TO_BE_OPENED | LOG_CLOSE_INDEX, false /*need_lock_log=false*/, |
| 7101 | false /*need_lock_index=false*/); | ||
| 7102 | |||
| 7103 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 31746 times.
|
31766 | if (checksum_alg_reset != binary_log::BINLOG_CHECKSUM_ALG_UNDEF) { |
| 7104 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
|
20 | assert(!is_relay_log); |
| 7105 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
|
20 | assert(binlog_checksum_options != checksum_alg_reset); |
| 7106 | 20 | binlog_checksum_options = checksum_alg_reset; | |
| 7107 | } | ||
| 7108 | /* | ||
| 7109 | Note that at this point, atomic_log_state != LOG_CLOSED | ||
| 7110 | (important for is_open()). | ||
| 7111 | */ | ||
| 7112 | |||
| 7113 |
3/6✓ Branch 0 taken 31766 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31766 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 31766 times.
✗ Branch 5 not taken.
|
31766 | DEBUG_SYNC(current_thd, "binlog_rotate_between_close_and_open"); |
| 7114 | /* | ||
| 7115 | new_file() is only used for rotation (in FLUSH LOGS or because size > | ||
| 7116 | max_binlog_size or max_relay_log_size). | ||
| 7117 | If this is a binary log, the Format_description_log_event at the beginning | ||
| 7118 | of the new file should have created=0 (to distinguish with the | ||
| 7119 | Format_description_log_event written at server startup, which should | ||
| 7120 | trigger temp tables deletion on slaves. | ||
| 7121 | */ | ||
| 7122 | |||
| 7123 | /* reopen index binlog file, BUG#34582 */ | ||
| 7124 | 31766 | file_to_open = index_file_name; | |
| 7125 |
1/2✓ Branch 0 taken 31766 times.
✗ Branch 1 not taken.
|
31766 | error = open_index_file(index_file_name, nullptr, |
| 7126 | false /*need_lock_index=false*/); | ||
| 7127 |
2/2✓ Branch 0 taken 31763 times.
✓ Branch 1 taken 3 times.
|
31766 | if (!error) { |
| 7128 | /* reopen the binary log file. */ | ||
| 7129 | 31763 | file_to_open = new_name_ptr; | |
| 7130 |
1/2✓ Branch 0 taken 31763 times.
✗ Branch 1 not taken.
|
31763 | error = open_binlog(old_name, new_name_ptr, max_size, |
| 7131 | true /*null_created_arg=true*/, | ||
| 7132 | false /*need_lock_index=false*/, | ||
| 7133 | true /*need_sid_lock=true*/, extra_description_event); | ||
| 7134 | } | ||
| 7135 | |||
| 7136 | /* handle reopening errors */ | ||
| 7137 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 31758 times.
|
31766 | if (error) { |
| 7138 | char errbuf[MYSYS_STRERROR_SIZE]; | ||
| 7139 |
4/8✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 8 times.
✗ Branch 7 not taken.
|
8 | my_printf_error(ER_CANT_OPEN_FILE, ER_THD(current_thd, ER_CANT_OPEN_FILE), |
| 7140 | MYF(ME_FATALERROR), file_to_open, error, | ||
| 7141 | my_strerror(errbuf, sizeof(errbuf), error)); | ||
| 7142 | 8 | close_on_error = true; | |
| 7143 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
16 | snprintf(close_on_error_msg, sizeof close_on_error_msg, |
| 7144 |
2/4✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
|
8 | ER_THD(current_thd, ER_CANT_OPEN_FILE), file_to_open, error, |
| 7145 | my_strerror(errbuf, sizeof(errbuf), error)); | ||
| 7146 | } | ||
| 7147 |
1/2✓ Branch 0 taken 31766 times.
✗ Branch 1 not taken.
|
31766 | my_free(old_name); |
| 7148 | |||
| 7149 | 31789 | end: | |
| 7150 | |||
| 7151 |
4/4✓ Branch 0 taken 31 times.
✓ Branch 1 taken 31758 times.
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 3 times.
|
31789 | if (error && close_on_error /* rotate, flush or reopen failed */) { |
| 7152 | /* | ||
| 7153 | Close whatever was left opened. | ||
| 7154 | |||
| 7155 | We are keeping the behavior as it exists today, ie, | ||
| 7156 | we disable logging and move on (see: BUG#51014). | ||
| 7157 | |||
| 7158 | TODO: as part of WL#1790 consider other approaches: | ||
| 7159 | - kill mysql (safety); | ||
| 7160 | - try multiple locations for opening a log file; | ||
| 7161 | - switch server to protected/readonly mode | ||
| 7162 | - ... | ||
| 7163 | */ | ||
| 7164 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
|
28 | if (binlog_error_action == ABORT_SERVER) { |
| 7165 | char abort_msg[ERR_CLOSE_MSG_LEN + 48]; | ||
| 7166 | ✗ | memset(abort_msg, 0, sizeof abort_msg); | |
| 7167 | ✗ | snprintf(abort_msg, sizeof abort_msg, | |
| 7168 | "%s, while rotating the binlog. " | ||
| 7169 | "Aborting the server", | ||
| 7170 | close_on_error_msg); | ||
| 7171 | ✗ | exec_binlog_error_action_abort(abort_msg); | |
| 7172 | } else | ||
| 7173 |
9/18✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 28 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 28 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 28 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 28 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 28 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 28 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 28 times.
✗ Branch 17 not taken.
|
28 | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_FOR_LOGGING, |
| 7174 | new_name_ptr != nullptr ? new_name_ptr : "new file", errno); | ||
| 7175 | |||
| 7176 |
1/2✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
|
28 | close(LOG_CLOSE_INDEX, false /*need_lock_log=false*/, |
| 7177 | false /*need_lock_index=false*/); | ||
| 7178 | } | ||
| 7179 | |||
| 7180 |
1/2✓ Branch 0 taken 31789 times.
✗ Branch 1 not taken.
|
31789 | mysql_mutex_unlock(&LOCK_index); |
| 7181 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 31789 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
31789 | if (need_lock_log) mysql_mutex_unlock(&LOCK_log); |
| 7182 | |||
| 7183 |
3/6✓ Branch 0 taken 31789 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31789 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 31789 times.
✗ Branch 5 not taken.
|
31789 | DEBUG_SYNC(current_thd, "after_disable_binlog"); |
| 7184 | 31789 | return error; | |
| 7185 | 31818 | } | |
| 7186 | |||
| 7187 | /** | ||
| 7188 | Called after an event has been written to the relay log by the IO | ||
| 7189 | thread. This flushes and possibly syncs the file (according to the | ||
| 7190 | sync options), rotates the file if it has grown over the limit, and | ||
| 7191 | finally calls signal_update(). | ||
| 7192 | |||
| 7193 | @note The caller must hold LOCK_log before invoking this function. | ||
| 7194 | |||
| 7195 | @param mi Master_info for the IO thread. | ||
| 7196 | |||
| 7197 | @retval false success | ||
| 7198 | @retval true error | ||
| 7199 | */ | ||
| 7200 | 1556617 | bool MYSQL_BIN_LOG::after_write_to_relay_log(Master_info *mi) { | |
| 7201 |
1/2✓ Branch 0 taken 1556617 times.
✗ Branch 1 not taken.
|
1556617 | DBUG_TRACE; |
| 7202 |
3/8✓ Branch 0 taken 1556617 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1556617 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1556617 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
1556617 | DBUG_PRINT("info", ("max_size: %lu", max_size)); |
| 7203 | |||
| 7204 | // Check pre-conditions | ||
| 7205 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 7206 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1556617 times.
|
1556617 | assert(is_relay_log); |
| 7207 | |||
| 7208 | /* | ||
| 7209 | We allow the relay log rotation by relay log size | ||
| 7210 | only if the trx parser is not inside a transaction. | ||
| 7211 | */ | ||
| 7212 | 1556617 | bool can_rotate = mi->transaction_parser.is_not_inside_transaction(); | |
| 7213 | |||
| 7214 | #ifndef NDEBUG | ||
| 7215 | 1556617 | if (m_binlog_file->get_real_file_size() > | |
| 7216 |
6/8✓ Branch 0 taken 1556617 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1556617 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18993 times.
✓ Branch 5 taken 1537624 times.
✓ Branch 6 taken 18806 times.
✓ Branch 7 taken 1537811 times.
|
1575610 | DBUG_EVALUATE_IF("rotate_replica_debug_group", 500, max_size) && |
| 7217 |
2/2✓ Branch 0 taken 18806 times.
✓ Branch 1 taken 187 times.
|
18993 | !can_rotate) { |
| 7218 |
3/8✓ Branch 0 taken 18806 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18806 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 18806 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
18806 | DBUG_PRINT("info", ("Postponing the rotation by size waiting for " |
| 7219 | "the end of the current transaction.")); | ||
| 7220 | } | ||
| 7221 | #endif | ||
| 7222 | |||
| 7223 | // Flush and sync | ||
| 7224 |
1/2✓ Branch 0 taken 1556617 times.
✗ Branch 1 not taken.
|
1556617 | bool error = flush_and_sync(false); |
| 7225 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1556611 times.
|
1556617 | if (error) { |
| 7226 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, |
| 7227 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
6 | ER_THD(current_thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), |
| 7228 | "failed to flush event to relay log file"); | ||
| 7229 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | truncate_relaylog_file(mi, atomic_binlog_end_pos); |
| 7230 | } else { | ||
| 7231 |
2/2✓ Branch 0 taken 325129 times.
✓ Branch 1 taken 1231482 times.
|
1556611 | if (can_rotate) { |
| 7232 |
1/2✓ Branch 0 taken 325129 times.
✗ Branch 1 not taken.
|
325129 | mysql_mutex_lock(&mi->data_lock); |
| 7233 | /* | ||
| 7234 | If the last event of the transaction has been flushed, we can add | ||
| 7235 | the GTID (if it is not empty) to the logged set, or else it will | ||
| 7236 | not be available in the Previous GTIDs of the next relay log file | ||
| 7237 | if we are going to rotate the relay log. | ||
| 7238 | */ | ||
| 7239 |
1/2✓ Branch 0 taken 325129 times.
✗ Branch 1 not taken.
|
325129 | const Gtid *last_gtid_queued = mi->get_queueing_trx_gtid(); |
| 7240 |
2/2✓ Branch 0 taken 59087 times.
✓ Branch 1 taken 266042 times.
|
325129 | if (!last_gtid_queued->is_empty()) { |
| 7241 |
1/2✓ Branch 0 taken 59087 times.
✗ Branch 1 not taken.
|
59087 | mi->rli->get_sid_lock()->rdlock(); |
| 7242 |
6/10✓ Branch 0 taken 59087 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 59081 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 6 times.
|
59087 | DBUG_SIGNAL_WAIT_FOR(current_thd, "updating_received_transaction_set", |
| 7243 | "reached_updating_received_transaction_set", | ||
| 7244 | "continue_updating_received_transaction_set"); | ||
| 7245 | 59087 | mi->rli->add_logged_gtid(last_gtid_queued->sidno, | |
| 7246 |
1/2✓ Branch 0 taken 59087 times.
✗ Branch 1 not taken.
|
59087 | last_gtid_queued->gno); |
| 7247 |
1/2✓ Branch 0 taken 59087 times.
✗ Branch 1 not taken.
|
59087 | mi->rli->get_sid_lock()->unlock(); |
| 7248 | } | ||
| 7249 | |||
| 7250 |
3/4✓ Branch 0 taken 325129 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 282589 times.
✓ Branch 3 taken 42540 times.
|
325129 | if (mi->is_queueing_trx()) { |
| 7251 |
1/2✓ Branch 0 taken 282589 times.
✗ Branch 1 not taken.
|
282589 | mi->finished_queueing(); |
| 7252 | |||
| 7253 |
1/2✓ Branch 0 taken 282589 times.
✗ Branch 1 not taken.
|
282589 | Trx_monitoring_info processing; |
| 7254 |
1/2✓ Branch 0 taken 282589 times.
✗ Branch 1 not taken.
|
282589 | Trx_monitoring_info last; |
| 7255 |
1/2✓ Branch 0 taken 282589 times.
✗ Branch 1 not taken.
|
282589 | mi->get_gtid_monitoring_info()->copy_info_to(&processing, &last); |
| 7256 | |||
| 7257 | // update the compression information | ||
| 7258 |
1/2✓ Branch 0 taken 282589 times.
✗ Branch 1 not taken.
|
282589 | binlog::global_context.monitoring_context() |
| 7259 |
1/2✓ Branch 0 taken 282589 times.
✗ Branch 1 not taken.
|
282589 | .transaction_compression() |
| 7260 | 282589 | .update(binlog::monitoring::log_type::RELAY, last.compression_type, | |
| 7261 | 282589 | last.gtid, last.end_time, last.compressed_bytes, | |
| 7262 |
1/2✓ Branch 0 taken 282589 times.
✗ Branch 1 not taken.
|
282589 | last.uncompressed_bytes, |
| 7263 | 282589 | mi->rli->get_gtid_set()->get_sid_map()); | |
| 7264 | } | ||
| 7265 |
1/2✓ Branch 0 taken 325129 times.
✗ Branch 1 not taken.
|
325129 | mysql_mutex_unlock(&mi->data_lock); |
| 7266 | |||
| 7267 | /* | ||
| 7268 | If relay log is too big, rotate. But only if not in the middle of a | ||
| 7269 | transaction when GTIDs are enabled. | ||
| 7270 | |||
| 7271 | Also rotate if a deferred flush request has been placed. | ||
| 7272 | |||
| 7273 | We now try to mimic the following master binlog behavior: "A transaction | ||
| 7274 | is written in one chunk to the binary log, so it is never split between | ||
| 7275 | several binary logs. Therefore, if you have big transactions, you might | ||
| 7276 | see binary log files larger than max_binlog_size." | ||
| 7277 | */ | ||
| 7278 | 325129 | if (m_binlog_file->get_real_file_size() > | |
| 7279 |
6/8✓ Branch 0 taken 325129 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 325129 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 324942 times.
✓ Branch 5 taken 187 times.
✓ Branch 6 taken 188 times.
✓ Branch 7 taken 324941 times.
|
650071 | DBUG_EVALUATE_IF("rotate_replica_debug_group", 500, max_size) || |
| 7280 |
3/4✓ Branch 0 taken 324942 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 324941 times.
|
324942 | mi->is_rotate_requested()) { |
| 7281 |
1/2✓ Branch 0 taken 188 times.
✗ Branch 1 not taken.
|
188 | error = new_file_without_locking(mi->get_mi_description_event()); |
| 7282 |
1/2✓ Branch 0 taken 188 times.
✗ Branch 1 not taken.
|
188 | mi->clear_rotate_requests(); |
| 7283 | } | ||
| 7284 | } | ||
| 7285 | } | ||
| 7286 | |||
| 7287 |
1/2✓ Branch 0 taken 1556617 times.
✗ Branch 1 not taken.
|
1556617 | lock_binlog_end_pos(); |
| 7288 | 1556617 | mi->rli->ign_master_log_name_end[0] = 0; | |
| 7289 |
1/2✓ Branch 0 taken 1556617 times.
✗ Branch 1 not taken.
|
1556617 | update_binlog_end_pos(false /*need_lock*/); |
| 7290 |
1/2✓ Branch 0 taken 1556617 times.
✗ Branch 1 not taken.
|
1556617 | harvest_bytes_written(mi->rli, true /*need_log_space_lock=true*/); |
| 7291 |
1/2✓ Branch 0 taken 1556617 times.
✗ Branch 1 not taken.
|
1556617 | unlock_binlog_end_pos(); |
| 7292 | |||
| 7293 | 1556617 | return error; | |
| 7294 | 1556617 | } | |
| 7295 | |||
| 7296 | 11666 | bool MYSQL_BIN_LOG::write_event(Log_event *ev, Master_info *mi) { | |
| 7297 |
1/2✓ Branch 0 taken 11666 times.
✗ Branch 1 not taken.
|
11666 | DBUG_TRACE; |
| 7298 | |||
| 7299 |
3/4✓ Branch 0 taken 11666 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 11665 times.
|
11666 | DBUG_EXECUTE_IF("fail_to_write_ignored_event_to_relay_log", { return true; }); |
| 7300 | // check preconditions | ||
| 7301 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11665 times.
|
11665 | assert(is_relay_log); |
| 7302 | |||
| 7303 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 7304 | |||
| 7305 | // write data | ||
| 7306 | 11665 | bool error = false; | |
| 7307 |
2/4✓ Branch 0 taken 11665 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11665 times.
✗ Branch 3 not taken.
|
11665 | if (!binary_event_serialize(ev, m_binlog_file)) { |
| 7308 | 11665 | bytes_written += ev->common_header->data_written; | |
| 7309 |
1/2✓ Branch 0 taken 11665 times.
✗ Branch 1 not taken.
|
11665 | error = after_write_to_relay_log(mi); |
| 7310 | } else { | ||
| 7311 | ✗ | mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, | |
| 7312 | ✗ | ER_THD(current_thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), | |
| 7313 | "failed to write event to the relay log file"); | ||
| 7314 | ✗ | truncate_relaylog_file(mi, atomic_binlog_end_pos); | |
| 7315 | ✗ | error = true; | |
| 7316 | } | ||
| 7317 | |||
| 7318 | 11665 | return error; | |
| 7319 | 11666 | } | |
| 7320 | |||
| 7321 | 1544952 | bool MYSQL_BIN_LOG::write_buffer(uchar *buf, uint len, Master_info *mi) { | |
| 7322 |
1/2✓ Branch 0 taken 1544952 times.
✗ Branch 1 not taken.
|
1544952 | DBUG_TRACE; |
| 7323 | |||
| 7324 | // check preconditions | ||
| 7325 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1544952 times.
|
1544952 | assert(is_relay_log); |
| 7326 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 7327 | |||
| 7328 | // write data | ||
| 7329 | 1544952 | bool error = false; | |
| 7330 |
2/4✓ Branch 0 taken 1544952 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1544952 times.
✗ Branch 3 not taken.
|
1544952 | if (m_binlog_file->write(pointer_cast<const uchar *>(buf), len) == 0) { |
| 7331 | 1544952 | bytes_written += len; | |
| 7332 |
1/2✓ Branch 0 taken 1544952 times.
✗ Branch 1 not taken.
|
1544952 | error = after_write_to_relay_log(mi); |
| 7333 | } else { | ||
| 7334 | ✗ | mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, | |
| 7335 | ✗ | ER_THD(current_thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), | |
| 7336 | "failed to write event to the relay log file"); | ||
| 7337 | ✗ | truncate_relaylog_file(mi, atomic_binlog_end_pos); | |
| 7338 | ✗ | error = true; | |
| 7339 | } | ||
| 7340 | |||
| 7341 | 1544952 | return error; | |
| 7342 | 1544952 | } | |
| 7343 | |||
| 7344 | 12477 | bool MYSQL_BIN_LOG::flush() { | |
| 7345 |
3/4✓ Branch 0 taken 12474 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 12474 times.
|
12477 | return m_binlog_file->is_open() && m_binlog_file->flush(); |
| 7346 | } | ||
| 7347 | |||
| 7348 | 1564690 | bool MYSQL_BIN_LOG::flush_and_sync(const bool force) { | |
| 7349 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 7350 | |||
| 7351 |
3/4✓ Branch 0 taken 1564690 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 1564684 times.
|
1564690 | if (m_binlog_file->flush()) return true; |
| 7352 | |||
| 7353 |
1/2✓ Branch 0 taken 1564684 times.
✗ Branch 1 not taken.
|
1564684 | std::pair<bool, bool> result = sync_binlog_file(force); |
| 7354 | |||
| 7355 | 1564684 | return result.first; | |
| 7356 | } | ||
| 7357 | |||
| 7358 | 142457 | void MYSQL_BIN_LOG::start_union_events(THD *thd, query_id_t query_id_param) { | |
| 7359 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 142457 times.
|
142457 | assert(!thd->binlog_evt_union.do_union); |
| 7360 | 142457 | thd->binlog_evt_union.do_union = true; | |
| 7361 | 142457 | thd->binlog_evt_union.unioned_events = false; | |
| 7362 | 142457 | thd->binlog_evt_union.unioned_events_trans = false; | |
| 7363 | 142457 | thd->binlog_evt_union.first_query_id = query_id_param; | |
| 7364 | 142457 | } | |
| 7365 | |||
| 7366 | 142457 | void MYSQL_BIN_LOG::stop_union_events(THD *thd) { | |
| 7367 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 142457 times.
|
142457 | assert(thd->binlog_evt_union.do_union); |
| 7368 | 142457 | thd->binlog_evt_union.do_union = false; | |
| 7369 | 142457 | } | |
| 7370 | |||
| 7371 | 234636 | bool MYSQL_BIN_LOG::is_query_in_union(THD *thd, query_id_t query_id_param) { | |
| 7372 |
2/2✓ Branch 0 taken 124 times.
✓ Branch 1 taken 234512 times.
|
234760 | return (thd->binlog_evt_union.do_union && |
| 7373 |
2/2✓ Branch 0 taken 52 times.
✓ Branch 1 taken 72 times.
|
234760 | query_id_param >= thd->binlog_evt_union.first_query_id); |
| 7374 | } | ||
| 7375 | |||
| 7376 | /* | ||
| 7377 | Updates thd's position-of-next-event variables | ||
| 7378 | after a *real* write a file. | ||
| 7379 | */ | ||
| 7380 | 2590011 | void MYSQL_BIN_LOG::update_thd_next_event_pos(THD *thd) { | |
| 7381 |
1/2✓ Branch 0 taken 2590011 times.
✗ Branch 1 not taken.
|
2590011 | if (likely(thd != nullptr)) { |
| 7382 | 2590011 | thd->set_next_event_pos(log_file_name, m_binlog_file->position()); | |
| 7383 | } | ||
| 7384 | 2590011 | } | |
| 7385 | |||
| 7386 | /* | ||
| 7387 | Moves the last bunch of rows from the pending Rows event to a cache (either | ||
| 7388 | transactional cache if is_transaction is @c true, or the non-transactional | ||
| 7389 | cache otherwise. Sets a new pending event. | ||
| 7390 | |||
| 7391 | @param thd a pointer to the user thread. | ||
| 7392 | @param evt a pointer to the row event. | ||
| 7393 | @param is_transactional @c true indicates a transactional cache, | ||
| 7394 | otherwise @c false a non-transactional. | ||
| 7395 | */ | ||
| 7396 | 8855704 | int MYSQL_BIN_LOG::flush_and_set_pending_rows_event(THD *thd, | |
| 7397 | Rows_log_event *event, | ||
| 7398 | bool is_transactional) { | ||
| 7399 |
1/2✓ Branch 0 taken 8855964 times.
✗ Branch 1 not taken.
|
8855704 | DBUG_TRACE; |
| 7400 | #ifdef WITH_WSREP | ||
| 7401 |
11/12✓ Branch 0 taken 8855963 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 317237 times.
✓ Branch 3 taken 8538726 times.
✓ Branch 4 taken 317235 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 317231 times.
✓ Branch 7 taken 4 times.
✓ Branch 8 taken 182 times.
✓ Branch 9 taken 317049 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 8855690 times.
|
8855964 | assert(WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()); |
| 7402 | #else | ||
| 7403 | assert(mysql_bin_log.is_open()); | ||
| 7404 | #endif /* WITH_WSREP */ | ||
| 7405 |
5/8✓ Branch 0 taken 8855868 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8855900 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 43 times.
✓ Branch 5 taken 8855857 times.
✓ Branch 6 taken 43 times.
✗ Branch 7 not taken.
|
8855872 | DBUG_PRINT("enter", ("event: %p", event)); |
| 7406 | |||
| 7407 | 8855900 | int error = 0; | |
| 7408 |
1/2✓ Branch 0 taken 8855962 times.
✗ Branch 1 not taken.
|
8855900 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); |
| 7409 | |||
| 7410 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8855962 times.
|
8855962 | assert(cache_mngr); |
| 7411 | |||
| 7412 | binlog_cache_data *cache_data = | ||
| 7413 | 8855962 | cache_mngr->get_binlog_cache_data(is_transactional); | |
| 7414 | |||
| 7415 |
5/8✓ Branch 0 taken 8855890 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8855848 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 43 times.
✓ Branch 5 taken 8855805 times.
✓ Branch 6 taken 43 times.
✗ Branch 7 not taken.
|
8855983 | DBUG_PRINT("info", ("cache_mngr->pending(): %p", cache_data->pending())); |
| 7416 | |||
| 7417 |
2/2✓ Branch 0 taken 4617685 times.
✓ Branch 1 taken 4238184 times.
|
8855848 | if (Rows_log_event *pending = cache_data->pending()) { |
| 7418 | /* | ||
| 7419 | Write pending event to the cache. | ||
| 7420 | */ | ||
| 7421 |
3/4✓ Branch 0 taken 4617660 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25 times.
✓ Branch 3 taken 4617635 times.
|
4617685 | if (cache_data->write_event(pending)) { |
| 7422 |
1/2✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
|
25 | report_cache_write_error(thd, is_transactional); |
| 7423 |
5/8✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 25 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 25 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5 times.
✓ Branch 7 taken 20 times.
|
50 | if (check_write_error(thd) && cache_data && |
| 7424 |
3/4✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 20 times.
|
25 | stmt_cannot_safely_rollback(thd)) |
| 7425 | 5 | cache_data->set_incident(); | |
| 7426 |
1/2✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
|
25 | delete pending; |
| 7427 | 25 | cache_data->set_pending(nullptr); | |
| 7428 | 25 | return 1; | |
| 7429 | } | ||
| 7430 | |||
| 7431 |
1/2✓ Branch 0 taken 4617638 times.
✗ Branch 1 not taken.
|
4617635 | delete pending; |
| 7432 | } | ||
| 7433 | |||
| 7434 | 8855861 | cache_data->set_pending(event); | |
| 7435 | |||
| 7436 | 8855732 | return error; | |
| 7437 | 8855757 | } | |
| 7438 | |||
| 7439 | /** | ||
| 7440 | Write an event to the binary log cache. | ||
| 7441 | */ | ||
| 7442 | |||
| 7443 | 879451 | bool MYSQL_BIN_LOG::write_event(Log_event *event_info) { | |
| 7444 | 879451 | THD *thd = event_info->thd; | |
| 7445 | 879451 | bool error = true; | |
| 7446 |
1/2✓ Branch 0 taken 879795 times.
✗ Branch 1 not taken.
|
879451 | DBUG_TRACE; |
| 7447 | |||
| 7448 |
2/2✓ Branch 0 taken 15414 times.
✓ Branch 1 taken 864381 times.
|
879795 | if (thd->binlog_evt_union.do_union) { |
| 7449 | /* | ||
| 7450 | In Stored function; Remember that function call caused an update. | ||
| 7451 | We will log the function call to the binary log on function exit | ||
| 7452 | */ | ||
| 7453 | 15414 | thd->binlog_evt_union.unioned_events = true; | |
| 7454 | 15414 | thd->binlog_evt_union.unioned_events_trans |= | |
| 7455 | 15414 | event_info->is_using_trans_cache(); | |
| 7456 | 15414 | return false; | |
| 7457 | } | ||
| 7458 | |||
| 7459 | /* | ||
| 7460 | We only end the statement if we are in a top-level statement. If | ||
| 7461 | we are inside a stored function, we do not end the statement since | ||
| 7462 | this will close all tables on the slave. But there can be a special case | ||
| 7463 | where we are inside a stored function/trigger and a SAVEPOINT is being | ||
| 7464 | set in side the stored function/trigger. This SAVEPOINT execution will | ||
| 7465 | force the pending event to be flushed without an STMT_END_F flag. This | ||
| 7466 | will result in a case where following DMLs will be considered as part of | ||
| 7467 | same statement and result in data loss on slave. Hence in this case we | ||
| 7468 | force the end_stmt to be true. | ||
| 7469 | */ | ||
| 7470 | bool const end_stmt = | ||
| 7471 |
2/2✓ Branch 0 taken 1922 times.
✓ Branch 1 taken 32 times.
|
1954 | (thd->in_sub_stmt && thd->lex->sql_command == SQLCOM_SAVEPOINT) |
| 7472 |
2/2✓ Branch 0 taken 1954 times.
✓ Branch 1 taken 862427 times.
|
1728762 | ? true |
| 7473 |
4/4✓ Branch 0 taken 15209 times.
✓ Branch 1 taken 849140 times.
✓ Branch 2 taken 12715 times.
✓ Branch 3 taken 2494 times.
|
864349 | : (thd->locked_tables_mode && thd->lex->requires_prelocking()); |
| 7474 |
2/4✓ Branch 0 taken 864402 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 864402 times.
|
864160 | if (thd->binlog_flush_pending_rows_event(end_stmt, |
| 7475 | 864381 | event_info->is_using_trans_cache())) | |
| 7476 | ✗ | return error; | |
| 7477 | |||
| 7478 | /* | ||
| 7479 | In most cases this is only called if 'is_open()' is true; in fact this is | ||
| 7480 | mostly called if is_open() *was* true a few instructions before, but it | ||
| 7481 | could have changed since. | ||
| 7482 | */ | ||
| 7483 | #ifdef WITH_WSREP | ||
| 7484 | /* If applier thread can have log-slave-updates=1 there-by causing | ||
| 7485 | applier action to get binlogged. | ||
| 7486 | But this should be avoided if applier thread is operating in emulation | ||
| 7487 | binlog mode. */ | ||
| 7488 |
13/18✓ Branch 0 taken 864407 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16658 times.
✓ Branch 3 taken 847749 times.
✓ Branch 4 taken 16643 times.
✓ Branch 5 taken 15 times.
✓ Branch 6 taken 12244 times.
✓ Branch 7 taken 4399 times.
✓ Branch 8 taken 2 times.
✓ Branch 9 taken 12242 times.
✓ Branch 10 taken 2 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✓ Branch 13 taken 8 times.
✓ Branch 14 taken 864233 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 864301 times.
✗ Branch 17 not taken.
|
864402 | if ((WSREP_EMULATE_BINLOG(thd) && !wsrep_thd_is_applying(thd)) || is_open()) { |
| 7489 | #else | ||
| 7490 | if (likely(is_open())) { | ||
| 7491 | #endif /* WITH_WSREP */ | ||
| 7492 | /* | ||
| 7493 | In the future we need to add to the following if tests like | ||
| 7494 | "do the involved tables match (to be implemented) | ||
| 7495 | binlog_[wild_]{do|ignore}_table?" (WL#1049)" | ||
| 7496 | */ | ||
| 7497 |
1/2✓ Branch 0 taken 864216 times.
✗ Branch 1 not taken.
|
864301 | const char *local_db = event_info->get_db(); |
| 7498 |
5/6✓ Branch 0 taken 864355 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 747419 times.
✓ Branch 3 taken 116936 times.
✓ Branch 4 taken 117186 times.
✓ Branch 5 taken 747177 times.
|
1611643 | if ((thd && !(thd->variables.option_bits & OPTION_BIN_LOG)) || |
| 7499 |
1/2✓ Branch 0 taken 747439 times.
✗ Branch 1 not taken.
|
747280 | (thd->lex->sql_command != SQLCOM_ROLLBACK_TO_SAVEPOINT && |
| 7500 |
2/2✓ Branch 0 taken 739565 times.
✓ Branch 1 taken 7874 times.
|
747439 | thd->lex->sql_command != SQLCOM_SAVEPOINT && |
| 7501 |
2/2✓ Branch 0 taken 739271 times.
✓ Branch 1 taken 199 times.
|
739565 | (!event_info->is_no_filter_event() && |
| 7502 |
3/4✓ Branch 0 taken 739513 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 250 times.
✓ Branch 3 taken 739263 times.
|
739271 | !binlog_filter->db_ok(local_db)))) |
| 7503 | 117186 | return false; | |
| 7504 | |||
| 7505 |
3/4✓ Branch 0 taken 163526 times.
✓ Branch 1 taken 583653 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 163547 times.
|
747177 | assert(event_info->is_using_trans_cache() || |
| 7506 | event_info->is_using_stmt_cache()); | ||
| 7507 | |||
| 7508 |
2/4✓ Branch 0 taken 747207 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 747207 times.
|
747200 | if (binlog_start_trans_and_stmt(thd, event_info)) return error; |
| 7509 | |||
| 7510 | 747207 | bool is_trans_cache = event_info->is_using_trans_cache(); | |
| 7511 |
1/2✓ Branch 0 taken 747229 times.
✗ Branch 1 not taken.
|
747211 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd); |
| 7512 | binlog_cache_data *cache_data = | ||
| 7513 | 747229 | cache_mngr->get_binlog_cache_data(is_trans_cache); | |
| 7514 | |||
| 7515 |
5/8✓ Branch 0 taken 747133 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 747107 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 95 times.
✓ Branch 5 taken 747012 times.
✓ Branch 6 taken 61 times.
✗ Branch 7 not taken.
|
747231 | DBUG_PRINT("info", ("event type: %d", event_info->get_type_code())); |
| 7516 | |||
| 7517 | /* | ||
| 7518 | No check for auto events flag here - this write method should | ||
| 7519 | never be called if auto-events are enabled. | ||
| 7520 | |||
| 7521 | Write first log events which describe the 'run environment' | ||
| 7522 | of the SQL command. If row-based binlogging, Insert_id, Rand | ||
| 7523 | and other kind of "setting context" events are not needed. | ||
| 7524 | */ | ||
| 7525 |
1/2✓ Branch 0 taken 747073 times.
✗ Branch 1 not taken.
|
747073 | if (thd) { |
| 7526 |
2/2✓ Branch 0 taken 415241 times.
✓ Branch 1 taken 331843 times.
|
747073 | if (!thd->is_current_stmt_binlog_format_row()) { |
| 7527 |
2/2✓ Branch 0 taken 183 times.
✓ Branch 1 taken 415058 times.
|
415241 | if (thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt) { |
| 7528 | Intvar_log_event e( | ||
| 7529 | thd, (uchar)binary_log::Intvar_event::LAST_INSERT_ID_EVENT, | ||
| 7530 | thd->first_successful_insert_id_in_prev_stmt_for_binlog, | ||
| 7531 |
1/2✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
|
183 | event_info->event_cache_type, event_info->event_logging_type); |
| 7532 |
2/4✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 183 times.
|
183 | if (cache_data->write_event(&e)) goto err; |
| 7533 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 182 times.
|
183 | if (event_info->is_using_immediate_logging()) |
| 7534 | 1 | thd->binlog_bytes_written += e.header()->data_written; | |
| 7535 |
1/2✓ Branch 0 taken 183 times.
✗ Branch 1 not taken.
|
183 | } |
| 7536 |
2/2✓ Branch 0 taken 87250 times.
✓ Branch 1 taken 327825 times.
|
415241 | if (thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0) { |
| 7537 |
3/8✓ Branch 0 taken 87250 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 87250 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 87250 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
87250 | DBUG_PRINT( |
| 7538 | "info", | ||
| 7539 | ("number of auto_inc intervals: %u", | ||
| 7540 | thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements())); | ||
| 7541 | Intvar_log_event e( | ||
| 7542 | thd, (uchar)binary_log::Intvar_event::INSERT_ID_EVENT, | ||
| 7543 | thd->auto_inc_intervals_in_cur_stmt_for_binlog.minimum(), | ||
| 7544 |
1/2✓ Branch 0 taken 87250 times.
✗ Branch 1 not taken.
|
87250 | event_info->event_cache_type, event_info->event_logging_type); |
| 7545 |
2/4✓ Branch 0 taken 87250 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 87250 times.
|
87250 | if (cache_data->write_event(&e)) goto err; |
| 7546 |
2/2✓ Branch 0 taken 71 times.
✓ Branch 1 taken 87179 times.
|
87250 | if (event_info->is_using_immediate_logging()) |
| 7547 | 71 | thd->binlog_bytes_written += e.header()->data_written; | |
| 7548 |
1/2✓ Branch 0 taken 87250 times.
✗ Branch 1 not taken.
|
87250 | } |
| 7549 |
2/2✓ Branch 0 taken 2098 times.
✓ Branch 1 taken 412977 times.
|
415075 | if (thd->rand_used) { |
| 7550 | 2098 | Rand_log_event e(thd, thd->rand_saved_seed1, thd->rand_saved_seed2, | |
| 7551 | event_info->event_cache_type, | ||
| 7552 |
1/2✓ Branch 0 taken 2098 times.
✗ Branch 1 not taken.
|
2098 | event_info->event_logging_type); |
| 7553 |
2/4✓ Branch 0 taken 2098 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2098 times.
|
2098 | if (cache_data->write_event(&e)) goto err; |
| 7554 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2098 times.
|
2098 | if (event_info->is_using_immediate_logging()) |
| 7555 | ✗ | thd->binlog_bytes_written += e.header()->data_written; | |
| 7556 |
1/2✓ Branch 0 taken 2098 times.
✗ Branch 1 not taken.
|
2098 | } |
| 7557 |
3/4✓ Branch 0 taken 415091 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9034 times.
✓ Branch 3 taken 406057 times.
|
415075 | if (!thd->user_var_events.empty()) { |
| 7558 |
3/4✓ Branch 0 taken 18143 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9109 times.
✓ Branch 3 taken 9034 times.
|
18143 | for (size_t i = 0; i < thd->user_var_events.size(); i++) { |
| 7559 |
1/2✓ Branch 0 taken 9109 times.
✗ Branch 1 not taken.
|
9109 | Binlog_user_var_event *user_var_event = thd->user_var_events[i]; |
| 7560 | |||
| 7561 | /* setting flags for user var log event */ | ||
| 7562 | 9109 | uchar flags = User_var_log_event::UNDEF_F; | |
| 7563 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 9098 times.
|
9109 | if (user_var_event->unsigned_flag) |
| 7564 | 11 | flags |= User_var_log_event::UNSIGNED_F; | |
| 7565 | |||
| 7566 | User_var_log_event e( | ||
| 7567 | 9109 | thd, user_var_event->user_var_event->entry_name.ptr(), | |
| 7568 | 9109 | user_var_event->user_var_event->entry_name.length(), | |
| 7569 | user_var_event->value, user_var_event->length, | ||
| 7570 | user_var_event->type, user_var_event->charset_number, flags, | ||
| 7571 |
1/2✓ Branch 0 taken 9109 times.
✗ Branch 1 not taken.
|
9109 | event_info->event_cache_type, event_info->event_logging_type); |
| 7572 |
2/4✓ Branch 0 taken 9109 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9109 times.
|
9109 | if (cache_data->write_event(&e)) goto err; |
| 7573 |
2/2✓ Branch 0 taken 28 times.
✓ Branch 1 taken 9081 times.
|
9109 | if (event_info->is_using_immediate_logging()) |
| 7574 | 28 | thd->binlog_bytes_written += e.header()->data_written; | |
| 7575 |
1/2✓ Branch 0 taken 9109 times.
✗ Branch 1 not taken.
|
9109 | } |
| 7576 | } | ||
| 7577 | } | ||
| 7578 | } | ||
| 7579 | |||
| 7580 | /* | ||
| 7581 | Write the event. | ||
| 7582 | */ | ||
| 7583 |
3/4✓ Branch 0 taken 747209 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 53 times.
✓ Branch 3 taken 747156 times.
|
746934 | if (cache_data->write_event(event_info)) goto err; |
| 7584 | |||
| 7585 |
3/4✓ Branch 0 taken 747158 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 37 times.
✓ Branch 3 taken 747121 times.
|
747156 | if (DBUG_EVALUATE_IF("injecting_fault_writing", 1, 0)) goto err; |
| 7586 |
2/2✓ Branch 0 taken 91295 times.
✓ Branch 1 taken 655821 times.
|
747121 | if (event_info->is_using_immediate_logging()) |
| 7587 | 91295 | thd->binlog_bytes_written += event_info->common_header->data_written; | |
| 7588 | |||
| 7589 | /* | ||
| 7590 | After writing the event, if the trx-cache was used and any unsafe | ||
| 7591 | change was written into it, the cache is marked as cannot safely | ||
| 7592 | roll back. | ||
| 7593 | */ | ||
| 7594 |
7/8✓ Branch 0 taken 583587 times.
✓ Branch 1 taken 163529 times.
✓ Branch 2 taken 583580 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1184 times.
✓ Branch 5 taken 582396 times.
✓ Branch 6 taken 1184 times.
✓ Branch 7 taken 745925 times.
|
747116 | if (is_trans_cache && stmt_cannot_safely_rollback(thd)) |
| 7595 | 1184 | cache_mngr->trx_cache.set_cannot_rollback(); | |
| 7596 | |||
| 7597 | 747049 | error = false; | |
| 7598 | |||
| 7599 | 747139 | err: | |
| 7600 |
2/2✓ Branch 0 taken 90 times.
✓ Branch 1 taken 747049 times.
|
747139 | if (error) { |
| 7601 |
1/2✓ Branch 0 taken 90 times.
✗ Branch 1 not taken.
|
90 | report_cache_write_error(thd, is_trans_cache); |
| 7602 |
5/8✓ Branch 0 taken 90 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 90 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✓ Branch 7 taken 86 times.
|
180 | if (check_write_error(thd) && cache_data && |
| 7603 |
3/4✓ Branch 0 taken 90 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 86 times.
|
90 | stmt_cannot_safely_rollback(thd)) |
| 7604 | 4 | cache_data->set_incident(); | |
| 7605 | } | ||
| 7606 | } | ||
| 7607 | |||
| 7608 | 747082 | return error; | |
| 7609 | 879682 | } | |
| 7610 | |||
| 7611 | /** | ||
| 7612 | The method executes rotation when LOCK_log is already acquired | ||
| 7613 | by the caller. | ||
| 7614 | |||
| 7615 | @param force_rotate caller can request the log rotation | ||
| 7616 | @param check_purge is set to true if rotation took place | ||
| 7617 | |||
| 7618 | @note | ||
| 7619 | If rotation fails, for instance the server was unable | ||
| 7620 | to create a new log file, we still try to write an | ||
| 7621 | incident event to the current log. | ||
| 7622 | |||
| 7623 | @note The caller must hold LOCK_log when invoking this function. | ||
| 7624 | |||
| 7625 | @retval | ||
| 7626 | nonzero - error in rotating routine. | ||
| 7627 | */ | ||
| 7628 | 12737 | int MYSQL_BIN_LOG::rotate(bool force_rotate, bool *check_purge) { | |
| 7629 | 12737 | int error = 0; | |
| 7630 |
1/2✓ Branch 0 taken 12737 times.
✗ Branch 1 not taken.
|
12737 | DBUG_TRACE; |
| 7631 | #ifdef WITH_WSREP | ||
| 7632 |
5/6✓ Branch 0 taken 240 times.
✓ Branch 1 taken 12497 times.
✓ Branch 2 taken 240 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 238 times.
|
12737 | if (WSREP_ON && wsrep_to_isolation) { |
| 7633 | 2 | *check_purge = false; | |
| 7634 |
1/24✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
|
2 | WSREP_DEBUG("avoiding binlog rotate due to TO isolation: %d", |
| 7635 | wsrep_to_isolation); | ||
| 7636 | 2 | return 0; | |
| 7637 | } | ||
| 7638 | #endif /* WITH_WSREP */ | ||
| 7639 | |||
| 7640 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12735 times.
|
12735 | assert(!is_relay_log); |
| 7641 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 7642 | |||
| 7643 | 12735 | *check_purge = false; | |
| 7644 | |||
| 7645 |
3/4✓ Branch 0 taken 12735 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9698 times.
✓ Branch 3 taken 3037 times.
|
25470 | if (DBUG_EVALUATE_IF("force_rotate", 1, 0) || force_rotate || |
| 7646 |
5/6✓ Branch 0 taken 12735 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4730 times.
✓ Branch 3 taken 4968 times.
✓ Branch 4 taken 8006 times.
✓ Branch 5 taken 4729 times.
|
30200 | (m_binlog_file->get_real_file_size() >= (my_off_t)max_size) || |
| 7647 |
3/4✓ Branch 0 taken 4730 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 4729 times.
|
4730 | DBUG_EVALUATE_IF("simulate_max_binlog_size", true, false)) { |
| 7648 |
1/2✓ Branch 0 taken 8006 times.
✗ Branch 1 not taken.
|
8006 | error = new_file_without_locking(nullptr); |
| 7649 | 8006 | *check_purge = true; | |
| 7650 |
1/2✓ Branch 0 taken 8006 times.
✗ Branch 1 not taken.
|
8006 | publish_coordinates_for_global_status(); |
| 7651 | } | ||
| 7652 | 12735 | return error; | |
| 7653 | 12737 | } | |
| 7654 | |||
| 7655 | 8986 | void MYSQL_BIN_LOG::auto_purge_at_server_startup() { | |
| 7656 | // first run the auto purge validations | ||
| 7657 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 8980 times.
|
8986 | if (check_auto_purge_conditions()) return; |
| 7658 | |||
| 7659 | 8980 | auto purge_time = calculate_auto_purge_lower_time_bound(); | |
| 7660 | 8980 | constexpr auto auto_purge{true}; | |
| 7661 | 8980 | purge_logs_before_date(purge_time, auto_purge); | |
| 7662 | } | ||
| 7663 | |||
| 7664 | /** | ||
| 7665 | The method executes logs purging routine. | ||
| 7666 | */ | ||
| 7667 | 6995 | void MYSQL_BIN_LOG::auto_purge() { | |
| 7668 | // first run the auto purge validations | ||
| 7669 |
3/4✓ Branch 0 taken 6995 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
✓ Branch 3 taken 6972 times.
|
7025 | if (check_auto_purge_conditions()) return; |
| 7670 | |||
| 7671 | // then we run the purge validations | ||
| 7672 | // if we run into out of memory, execute binlog_error_action_abort | ||
| 7673 |
1/2✓ Branch 0 taken 6972 times.
✗ Branch 1 not taken.
|
6972 | const auto [is_invalid_purge, purge_error] = check_purge_conditions(*this); |
| 7674 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 6942 times.
|
6972 | if (is_invalid_purge) { |
| 7675 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
|
30 | if (purge_error == LOG_INFO_MEM) { |
| 7676 | /* purecov: begin inspected */ | ||
| 7677 | // OOM | ||
| 7678 | ✗ | exec_binlog_error_action_abort( | |
| 7679 | "Out of memory happened while checking if " | ||
| 7680 | "instance was locked for backup"); | ||
| 7681 | /* purecov: end */ | ||
| 7682 | } | ||
| 7683 | 30 | return; | |
| 7684 | } | ||
| 7685 | |||
| 7686 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6942 times.
|
6942 | assert(purge_error == 0); |
| 7687 | |||
| 7688 |
3/6✓ Branch 0 taken 6942 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6942 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6942 times.
✗ Branch 5 not taken.
|
6942 | DEBUG_SYNC(current_thd, "at_purge_logs_before_date"); |
| 7689 | |||
| 7690 |
1/2✓ Branch 0 taken 6942 times.
✗ Branch 1 not taken.
|
6942 | auto purge_time = calculate_auto_purge_lower_time_bound(); |
| 7691 | 6942 | constexpr auto auto_purge{true}; | |
| 7692 | /* | ||
| 7693 | Flush logs for storage engines, so that the last transaction | ||
| 7694 | is persisted inside storage engines. | ||
| 7695 | */ | ||
| 7696 |
1/2✓ Branch 0 taken 6942 times.
✗ Branch 1 not taken.
|
6942 | ha_flush_logs(); |
| 7697 |
1/2✓ Branch 0 taken 6942 times.
✗ Branch 1 not taken.
|
6942 | purge_logs_before_date(purge_time, auto_purge); |
| 7698 | |||
| 7699 |
3/4✓ Branch 0 taken 42 times.
✓ Branch 1 taken 6900 times.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
|
6942 | if (binlog_space_limit) purge_logs_by_size(true); |
| 7700 | } | ||
| 7701 | |||
| 7702 | /** | ||
| 7703 | Execute a FLUSH LOGS statement. | ||
| 7704 | |||
| 7705 | The method is a shortcut of @c rotate() and @c purge(). | ||
| 7706 | LOCK_log is acquired prior to rotate and is released after it. | ||
| 7707 | |||
| 7708 | @param thd Current session. | ||
| 7709 | @param force_rotate caller can request the log rotation | ||
| 7710 | |||
| 7711 | @retval | ||
| 7712 | nonzero - error in rotating routine. | ||
| 7713 | */ | ||
| 7714 | 1997 | int MYSQL_BIN_LOG::rotate_and_purge(THD *thd, bool force_rotate) { | |
| 7715 | 1997 | int error = 0; | |
| 7716 |
1/2✓ Branch 0 taken 1997 times.
✗ Branch 1 not taken.
|
1997 | DBUG_TRACE; |
| 7717 | 1997 | bool check_purge = false; | |
| 7718 | |||
| 7719 | /* | ||
| 7720 | FLUSH BINARY LOGS command should ignore 'read-only' and 'super_read_only' | ||
| 7721 | options so that it can update 'mysql.gtid_executed' replication repository | ||
| 7722 | table. | ||
| 7723 | */ | ||
| 7724 | 1997 | thd->set_skip_readonly_check(); | |
| 7725 | /* | ||
| 7726 | Wait for handlerton to insert any pending information into the binlog. | ||
| 7727 | For e.g. ha_ndbcluster which updates the binlog asynchronously this is | ||
| 7728 | needed so that the user see its own commands in the binlog. | ||
| 7729 | */ | ||
| 7730 |
1/2✓ Branch 0 taken 1997 times.
✗ Branch 1 not taken.
|
1997 | ha_binlog_wait(thd); |
| 7731 | |||
| 7732 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1997 times.
|
1997 | assert(!is_relay_log); |
| 7733 |
1/2✓ Branch 0 taken 1997 times.
✗ Branch 1 not taken.
|
1997 | mysql_mutex_lock(&LOCK_log); |
| 7734 |
1/2✓ Branch 0 taken 1997 times.
✗ Branch 1 not taken.
|
1997 | error = rotate(force_rotate, &check_purge); |
| 7735 | /* | ||
| 7736 | NOTE: Run purge_logs wo/ holding LOCK_log because it does not need | ||
| 7737 | the mutex. Otherwise causes various deadlocks. | ||
| 7738 | */ | ||
| 7739 |
1/2✓ Branch 0 taken 1997 times.
✗ Branch 1 not taken.
|
1997 | mysql_mutex_unlock(&LOCK_log); |
| 7740 | |||
| 7741 |
5/6✓ Branch 0 taken 1981 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 1979 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1979 times.
✗ Branch 5 not taken.
|
1997 | if (!error && check_purge) auto_purge(); |
| 7742 | |||
| 7743 | 1997 | return error; | |
| 7744 | 1997 | } | |
| 7745 | |||
| 7746 | 4027 | uint MYSQL_BIN_LOG::next_file_id() { | |
| 7747 | uint res; | ||
| 7748 | 4027 | mysql_mutex_lock(&LOCK_log); | |
| 7749 | 4027 | res = file_id++; | |
| 7750 | 4027 | mysql_mutex_unlock(&LOCK_log); | |
| 7751 | 4027 | return res; | |
| 7752 | } | ||
| 7753 | |||
| 7754 | 13259 | int MYSQL_BIN_LOG::get_gtid_executed(Sid_map *sid_map, Gtid_set *gtid_set) { | |
| 7755 |
1/2✓ Branch 0 taken 13259 times.
✗ Branch 1 not taken.
|
13259 | DBUG_TRACE; |
| 7756 | 13259 | int error = 0; | |
| 7757 | |||
| 7758 |
1/2✓ Branch 0 taken 13259 times.
✗ Branch 1 not taken.
|
13259 | mysql_mutex_lock(&mysql_bin_log.LOCK_commit); |
| 7759 |
1/2✓ Branch 0 taken 13259 times.
✗ Branch 1 not taken.
|
13259 | global_sid_lock->wrlock(); |
| 7760 | |||
| 7761 |
1/2✓ Branch 0 taken 13259 times.
✗ Branch 1 not taken.
|
13259 | enum_return_status return_status = global_sid_map->copy(sid_map); |
| 7762 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13259 times.
|
13259 | if (return_status != RETURN_STATUS_OK) { |
| 7763 | ✗ | error = 1; | |
| 7764 | ✗ | goto end; | |
| 7765 | } | ||
| 7766 | |||
| 7767 |
1/2✓ Branch 0 taken 13259 times.
✗ Branch 1 not taken.
|
13259 | return_status = gtid_set->add_gtid_set(gtid_state->get_executed_gtids()); |
| 7768 |
1/2✓ Branch 0 taken 13259 times.
✗ Branch 1 not taken.
|
13259 | if (return_status != RETURN_STATUS_OK) error = 1; |
| 7769 | |||
| 7770 | 13259 | end: | |
| 7771 |
1/2✓ Branch 0 taken 13259 times.
✗ Branch 1 not taken.
|
13259 | global_sid_lock->unlock(); |
| 7772 |
1/2✓ Branch 0 taken 13259 times.
✗ Branch 1 not taken.
|
13259 | mysql_mutex_unlock(&mysql_bin_log.LOCK_commit); |
| 7773 | |||
| 7774 | 13259 | return error; | |
| 7775 | 13259 | } | |
| 7776 | |||
| 7777 | /** | ||
| 7778 | Write the contents of the given IO_CACHE to the binary log. | ||
| 7779 | |||
| 7780 | The cache will be reset as a READ_CACHE to be able to read the | ||
| 7781 | contents from it. | ||
| 7782 | |||
| 7783 | The data will be post-processed: see class Binlog_event_writer for | ||
| 7784 | details. | ||
| 7785 | |||
| 7786 | @param cache Events will be read from this IO_CACHE. | ||
| 7787 | @param writer Events will be written to this Binlog_event_writer. | ||
| 7788 | |||
| 7789 | @retval true IO error. | ||
| 7790 | @retval false Success. | ||
| 7791 | |||
| 7792 | @see MYSQL_BIN_LOG::write_cache | ||
| 7793 | */ | ||
| 7794 | 2590017 | bool MYSQL_BIN_LOG::do_write_cache(Binlog_cache_storage *cache, | |
| 7795 | Binlog_event_writer *writer) { | ||
| 7796 |
1/2✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
|
2590017 | DBUG_TRACE; |
| 7797 | |||
| 7798 |
4/6✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2590016 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
2590017 | DBUG_EXECUTE_IF("simulate_do_write_cache_failure", { |
| 7799 | /* | ||
| 7800 | see binlog_cache_data::write_event() that reacts on | ||
| 7801 | @c simulate_disk_full_at_flush_pending. | ||
| 7802 | */ | ||
| 7803 | DBUG_SET("-d,simulate_do_write_cache_failure"); | ||
| 7804 | return true; | ||
| 7805 | }); | ||
| 7806 | |||
| 7807 | #ifndef NDEBUG | ||
| 7808 |
1/2✓ Branch 0 taken 2590016 times.
✗ Branch 1 not taken.
|
2590016 | uint64 expected_total_len = cache->length(); |
| 7809 |
5/8✓ Branch 0 taken 2590016 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590016 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 114 times.
✓ Branch 5 taken 2589902 times.
✓ Branch 6 taken 114 times.
✗ Branch 7 not taken.
|
2590016 | DBUG_PRINT("info", ("bytes in cache= %" PRIu64, expected_total_len)); |
| 7810 | #endif | ||
| 7811 | |||
| 7812 | 2590016 | bool error = false; | |
| 7813 |
3/4✓ Branch 0 taken 2590016 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 2590014 times.
|
2590016 | if (cache->copy_to(writer, &error)) { |
| 7814 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
2 | if (error) report_binlog_write_error(); |
| 7815 | 2 | return true; | |
| 7816 | } | ||
| 7817 | 2590014 | return false; | |
| 7818 | 2590017 | } | |
| 7819 | |||
| 7820 | /** | ||
| 7821 | Writes an incident event to stmt_cache. | ||
| 7822 | |||
| 7823 | @param ev Incident event to be written | ||
| 7824 | @param thd Thread variable | ||
| 7825 | @param need_lock_log If true, will acquire LOCK_log; otherwise the | ||
| 7826 | caller should already have acquired LOCK_log. | ||
| 7827 | @param err_msg Error message written to log file for the incident. | ||
| 7828 | @param do_flush_and_sync If true, will call flush_and_sync(), rotate() and | ||
| 7829 | purge(). | ||
| 7830 | |||
| 7831 | @retval false error | ||
| 7832 | @retval true success | ||
| 7833 | */ | ||
| 7834 | 11 | bool MYSQL_BIN_LOG::write_incident(Incident_log_event *ev, THD *thd, | |
| 7835 | bool need_lock_log, const char *err_msg, | ||
| 7836 | bool do_flush_and_sync) { | ||
| 7837 | 11 | uint error = 0; | |
| 7838 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | DBUG_TRACE; |
| 7839 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
|
11 | assert(err_msg); |
| 7840 | |||
| 7841 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
|
11 | if (!is_open()) return error; |
| 7842 | |||
| 7843 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd); |
| 7844 | |||
| 7845 | /* | ||
| 7846 | thd->cache_mngr may be uninitialized when first transaction resulted in an | ||
| 7847 | incident. If there is no cache manager exists for the session, then we | ||
| 7848 | create one, so that a GTID is generated and is written prior to flushing | ||
| 7849 | the stmt_cache. | ||
| 7850 | */ | ||
| 7851 |
3/4✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 10 times.
|
22 | if (cache_mngr == nullptr || |
| 7852 |
3/4✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 10 times.
|
11 | DBUG_EVALUATE_IF("simulate_cache_creation_failure", 1, 0)) { |
| 7853 |
3/6✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
2 | if (thd->binlog_setup_trx_data() || |
| 7854 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | DBUG_EVALUATE_IF("simulate_cache_creation_failure", 1, 0)) { |
| 7855 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | auto gtid_mode = global_gtid_mode.get(); |
| 7856 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
1 | if (gtid_mode == Gtid_mode::ON || gtid_mode == Gtid_mode::ON_PERMISSIVE) { |
| 7857 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | std::ostringstream message; |
| 7858 | |||
| 7859 | message << "Could not create IO cache while writing an incident event " | ||
| 7860 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | "to the binary log. Since GTID_MODE = " |
| 7861 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | << gtid_mode |
| 7862 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | << ", server is unable to proceed with logging. Query: '"; |
| 7863 | /** | ||
| 7864 | The reason for the error may be that the query was | ||
| 7865 | huge. Better cut it to not run into resource problems. | ||
| 7866 | */ | ||
| 7867 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | message.write(thd->query().str, MYSQL_ERRMSG_SIZE); |
| 7868 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | message << "'."; |
| 7869 | |||
| 7870 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | handle_binlog_flush_or_sync_error(thd, true, message.str().c_str()); |
| 7871 | 1 | return true; | |
| 7872 | 1 | } | |
| 7873 | } else | ||
| 7874 | ✗ | cache_mngr = thd_get_cache_mngr(thd); | |
| 7875 | } | ||
| 7876 | |||
| 7877 | #ifndef NDEBUG | ||
| 7878 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | if (DBUG_EVALUATE_IF("simulate_write_incident_event_into_binlog_directly", 1, |
| 7879 |
4/4✓ Branch 0 taken 1 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 9 times.
|
11 | 0) && |
| 7880 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | !cache_mngr->stmt_cache.is_binlog_empty()) { |
| 7881 | /* The stmt_cache contains corruption data, so we can reset it. */ | ||
| 7882 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | cache_mngr->stmt_cache.reset(); |
| 7883 | } | ||
| 7884 | #endif | ||
| 7885 | |||
| 7886 | /* | ||
| 7887 | If there is no binlog cache then we write incidents directly | ||
| 7888 | into the binlog. If caller needs GTIDs it has to setup the | ||
| 7889 | binlog cache (for the injector thread). | ||
| 7890 | */ | ||
| 7891 |
3/4✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 9 times.
|
20 | if (cache_mngr == nullptr || |
| 7892 |
3/4✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 9 times.
|
10 | DBUG_EVALUATE_IF("simulate_write_incident_event_into_binlog_directly", 1, |
| 7893 | 0)) { | ||
| 7894 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (need_lock_log) |
| 7895 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | mysql_mutex_lock(&LOCK_log); |
| 7896 | else | ||
| 7897 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 7898 | /* Write an incident event into binlog directly. */ | ||
| 7899 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | error = write_event_to_binlog(ev); |
| 7900 | /* | ||
| 7901 | Write an error to log. So that user might have a chance | ||
| 7902 | to be alerted and explore incident details. | ||
| 7903 | */ | ||
| 7904 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (!error) |
| 7905 |
8/16✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
|
1 | LogErr(ERROR_LEVEL, ER_BINLOG_LOGGING_INCIDENT_TO_STOP_SLAVES, err_msg); |
| 7906 | } else // (cache_mngr != NULL) | ||
| 7907 | { | ||
| 7908 |
3/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 3 times.
|
9 | if (!cache_mngr->stmt_cache.is_binlog_empty()) { |
| 7909 | /* The stmt_cache contains corruption data, so we can reset it. */ | ||
| 7910 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | cache_mngr->stmt_cache.reset(); |
| 7911 | } | ||
| 7912 |
3/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 6 times.
|
9 | if (!cache_mngr->trx_cache.is_binlog_empty()) { |
| 7913 | /* The trx_cache contains corruption data, so we can reset it. */ | ||
| 7914 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | cache_mngr->trx_cache.reset(); |
| 7915 | } | ||
| 7916 | /* | ||
| 7917 | Write the incident event into stmt_cache, so that a GTID is generated and | ||
| 7918 | written for it prior to flushing the stmt_cache. | ||
| 7919 | */ | ||
| 7920 | 9 | binlog_cache_data *cache_data = cache_mngr->get_binlog_cache_data(false); | |
| 7921 |
3/6✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9 times.
|
9 | if ((error = cache_data->write_event(ev))) { |
| 7922 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_EVENT_WRITE_TO_STMT_CACHE_FAILED); | |
| 7923 | ✗ | cache_mngr->stmt_cache.reset(); | |
| 7924 | ✗ | return error; | |
| 7925 | } | ||
| 7926 | |||
| 7927 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2 times.
|
9 | if (need_lock_log) |
| 7928 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | mysql_mutex_lock(&LOCK_log); |
| 7929 | else | ||
| 7930 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 7931 | } | ||
| 7932 | |||
| 7933 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
|
10 | if (do_flush_and_sync) { |
| 7934 |
4/8✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 8 times.
✗ Branch 7 not taken.
|
8 | if (!error && !(error = flush_and_sync())) { |
| 7935 | 8 | bool check_purge = false; | |
| 7936 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
8 | update_binlog_end_pos(); |
| 7937 | 8 | is_rotating_caused_by_incident = true; | |
| 7938 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
8 | error = rotate(true, &check_purge); |
| 7939 | 8 | is_rotating_caused_by_incident = false; | |
| 7940 |
3/6✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
|
8 | if (!error && check_purge) auto_purge(); |
| 7941 | } | ||
| 7942 | } | ||
| 7943 | |||
| 7944 |
3/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
|
10 | if (need_lock_log) mysql_mutex_unlock(&LOCK_log); |
| 7945 | |||
| 7946 | /* | ||
| 7947 | Write an error to log. So that user might have a chance | ||
| 7948 | to be alerted and explore incident details. | ||
| 7949 | */ | ||
| 7950 |
2/4✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
|
10 | if (!error && cache_mngr != nullptr) |
| 7951 |
8/16✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 10 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 10 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 10 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 10 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 10 times.
✗ Branch 15 not taken.
|
10 | LogErr(ERROR_LEVEL, ER_BINLOG_LOGGING_INCIDENT_TO_STOP_SLAVES, err_msg); |
| 7952 | |||
| 7953 | 10 | return error; | |
| 7954 | 11 | } | |
| 7955 | |||
| 7956 | 56 | bool MYSQL_BIN_LOG::write_stmt_directly(THD *thd, const char *stmt, | |
| 7957 | size_t stmt_len, | ||
| 7958 | enum_sql_command sql_command) { | ||
| 7959 | 56 | bool ret = false; | |
| 7960 | /* backup the original command */ | ||
| 7961 | 56 | enum_sql_command save_sql_command = thd->lex->sql_command; | |
| 7962 | 56 | thd->lex->sql_command = sql_command; | |
| 7963 | |||
| 7964 | 56 | if (thd->binlog_query(THD::STMT_QUERY_TYPE, stmt, stmt_len, false, false, | |
| 7965 |
2/4✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 56 times.
|
112 | false, 0) || |
| 7966 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
|
56 | commit(thd, false) != TC_LOG::RESULT_SUCCESS) { |
| 7967 | ✗ | ret = true; | |
| 7968 | } | ||
| 7969 | |||
| 7970 | 56 | thd->lex->sql_command = save_sql_command; | |
| 7971 | 56 | return ret; | |
| 7972 | } | ||
| 7973 | |||
| 7974 | /** | ||
| 7975 | Creates an incident event and writes it to the binary log. | ||
| 7976 | |||
| 7977 | @param thd Thread variable | ||
| 7978 | @param need_lock_log If the binary lock should be locked or not | ||
| 7979 | @param err_msg Error message written to log file for the incident. | ||
| 7980 | @param do_flush_and_sync If true, will call flush_and_sync(), rotate() and | ||
| 7981 | purge(). | ||
| 7982 | |||
| 7983 | @retval | ||
| 7984 | 0 error | ||
| 7985 | @retval | ||
| 7986 | 1 success | ||
| 7987 | */ | ||
| 7988 | 11 | bool MYSQL_BIN_LOG::write_incident(THD *thd, bool need_lock_log, | |
| 7989 | const char *err_msg, | ||
| 7990 | bool do_flush_and_sync) { | ||
| 7991 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | DBUG_TRACE; |
| 7992 | |||
| 7993 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
|
11 | if (!is_open()) return false; |
| 7994 | |||
| 7995 | 11 | LEX_CSTRING write_error_msg = {err_msg, strlen(err_msg)}; | |
| 7996 | 11 | binary_log::Incident_event::enum_incident incident = | |
| 7997 | binary_log::Incident_event::INCIDENT_LOST_EVENTS; | ||
| 7998 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | Incident_log_event ev(thd, incident, write_error_msg); |
| 7999 | |||
| 8000 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | return write_incident(&ev, thd, need_lock_log, err_msg, do_flush_and_sync); |
| 8001 | 11 | } | |
| 8002 | |||
| 8003 | /* | ||
| 8004 | Write the event into current binlog directly without going though a session | ||
| 8005 | binlog cache. It will update the event's log_pos and set checksum accordingly. | ||
| 8006 | binary_event_serialize can be called directly if log_pos should not be | ||
| 8007 | updated. | ||
| 8008 | */ | ||
| 8009 | 205802 | inline bool MYSQL_BIN_LOG::write_event_to_binlog(Log_event *ev) { | |
| 8010 | 205802 | ev->common_footer->checksum_alg = | |
| 8011 | 205802 | is_relay_log | |
| 8012 |
2/2✓ Branch 0 taken 137926 times.
✓ Branch 1 taken 67876 times.
|
205802 | ? relay_log_checksum_alg |
| 8013 | 67876 | : static_cast<enum_binlog_checksum_alg>(binlog_checksum_options); | |
| 8014 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 205802 times.
|
205802 | assert(ev->common_footer->checksum_alg != |
| 8015 | binary_log::BINLOG_CHECKSUM_ALG_UNDEF); | ||
| 8016 | |||
| 8017 | /* | ||
| 8018 | Stores current position into log_pos, it is used to calculate correctly | ||
| 8019 | end_log_pos by adding data_written in Log_event::write_header(). | ||
| 8020 | */ | ||
| 8021 | 205802 | ev->common_header->log_pos = m_binlog_file->position(); | |
| 8022 | |||
| 8023 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 205802 times.
|
205801 | if (binary_event_serialize(ev, m_binlog_file)) return true; |
| 8024 | |||
| 8025 | 205802 | add_bytes_written(ev->common_header->data_written); | |
| 8026 | 205802 | return false; | |
| 8027 | } | ||
| 8028 | |||
| 8029 | /* Write the event into current binlog and flush and sync */ | ||
| 8030 | 8986 | bool MYSQL_BIN_LOG::write_event_to_binlog_and_sync(Log_event *ev) { | |
| 8031 |
3/6✓ Branch 0 taken 8986 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8986 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 8986 times.
|
17972 | if (write_event_to_binlog(ev) || m_binlog_file->flush() || |
| 8032 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8986 times.
|
8986 | m_binlog_file->sync()) |
| 8033 | ✗ | return true; | |
| 8034 | |||
| 8035 | 8986 | update_binlog_end_pos(); | |
| 8036 | 8986 | return false; | |
| 8037 | } | ||
| 8038 | |||
| 8039 | /** | ||
| 8040 | Write the contents of the statement or transaction cache to the binary log. | ||
| 8041 | |||
| 8042 | Comparison with do_write_cache: | ||
| 8043 | |||
| 8044 | - do_write_cache is a lower-level function that only performs the | ||
| 8045 | actual write. | ||
| 8046 | |||
| 8047 | - write_cache is a higher-level function that calls do_write_cache | ||
| 8048 | and additionally performs some maintenance tasks, including: | ||
| 8049 | - report any errors that occurred | ||
| 8050 | - write incident event if needed | ||
| 8051 | - update gtid_state | ||
| 8052 | - update thd.binlog_next_event_pos | ||
| 8053 | |||
| 8054 | @param thd Thread variable | ||
| 8055 | |||
| 8056 | @param cache_data Events will be read from the IO_CACHE of this | ||
| 8057 | cache_data object. | ||
| 8058 | |||
| 8059 | @param writer Events will be written to this Binlog_event_writer. | ||
| 8060 | |||
| 8061 | @retval true IO error. | ||
| 8062 | @retval false Success. | ||
| 8063 | |||
| 8064 | @note We only come here if there is something in the cache. | ||
| 8065 | @note Whatever is in the cache is always a complete transaction. | ||
| 8066 | @note 'cache' needs to be reinitialized after this functions returns. | ||
| 8067 | */ | ||
| 8068 | 2590017 | bool MYSQL_BIN_LOG::write_cache(THD *thd, binlog_cache_data *cache_data, | |
| 8069 | Binlog_event_writer *writer) { | ||
| 8070 |
1/2✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
|
2590017 | DBUG_TRACE; |
| 8071 | #ifdef WITH_WSREP | ||
| 8072 |
8/10✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 59129 times.
✓ Branch 3 taken 2530888 times.
✓ Branch 4 taken 59119 times.
✓ Branch 5 taken 10 times.
✓ Branch 6 taken 59063 times.
✓ Branch 7 taken 56 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 59063 times.
|
2590017 | if (WSREP_EMULATE_BINLOG(thd)) return 0; |
| 8073 | #endif /* WITH_WSREP */ | ||
| 8074 | |||
| 8075 | 2590017 | Binlog_cache_storage *cache = cache_data->get_cache(); | |
| 8076 | 2590017 | bool incident = cache_data->has_incident(); | |
| 8077 | |||
| 8078 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 8079 | |||
| 8080 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2590017 times.
|
2590017 | assert(is_open()); |
| 8081 |
1/2✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
|
2590017 | if (likely(is_open())) // Should always be true |
| 8082 | { | ||
| 8083 | /* | ||
| 8084 | We only bother to write to the binary log if there is anything | ||
| 8085 | to write. | ||
| 8086 | |||
| 8087 | @todo Is this check redundant? Probably this is only called if | ||
| 8088 | there is anything in the cache (see @note in comment above this | ||
| 8089 | function). Check if we can replace this by an assertion. /Sven | ||
| 8090 | */ | ||
| 8091 |
2/4✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2590017 times.
✗ Branch 3 not taken.
|
2590017 | if (!cache->is_empty()) { |
| 8092 |
2/28✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2590017 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
|
2590017 | DBUG_EXECUTE_IF("crash_before_writing_xid", { |
| 8093 | if (do_write_cache(cache, writer)) | ||
| 8094 | DBUG_PRINT("info", ("error writing binlog cache: %d", write_error)); | ||
| 8095 | flush_and_sync(true); | ||
| 8096 | DBUG_PRINT("info", ("crashing before writing xid")); | ||
| 8097 | DBUG_SUICIDE(); | ||
| 8098 | }); | ||
| 8099 |
3/4✓ Branch 0 taken 2590017 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2590014 times.
|
2590017 | if (do_write_cache(cache, writer)) goto err; |
| 8100 | |||
| 8101 | 2590014 | const char *err_msg = | |
| 8102 | "Non-transactional changes did not get into " | ||
| 8103 | "the binlog."; | ||
| 8104 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2590012 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2590014 times.
|
2590016 | if (incident && |
| 8105 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
2 | write_incident(thd, false /*need_lock_log=false*/, err_msg, |
| 8106 | false /*do_flush_and_sync==false*/)) { | ||
| 8107 | ✗ | report_binlog_write_error(); | |
| 8108 | ✗ | goto err; | |
| 8109 | } | ||
| 8110 |
4/6✓ Branch 0 taken 2590014 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2590011 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
|
2590014 | DBUG_EXECUTE_IF("half_binlogged_transaction", DBUG_SUICIDE();); |
| 8111 | } | ||
| 8112 |
1/2✓ Branch 0 taken 2590011 times.
✗ Branch 1 not taken.
|
2590011 | update_thd_next_event_pos(thd); |
| 8113 | } | ||
| 8114 | |||
| 8115 | 2590011 | return false; | |
| 8116 | |||
| 8117 | 3 | err: | |
| 8118 | 3 | thd->commit_error = THD::CE_FLUSH_ERROR; | |
| 8119 | |||
| 8120 | 3 | return true; | |
| 8121 | 2590014 | } | |
| 8122 | |||
| 8123 | 4 | void MYSQL_BIN_LOG::report_binlog_write_error() { | |
| 8124 | char errbuf[MYSYS_STRERROR_SIZE]; | ||
| 8125 | |||
| 8126 | 4 | write_error = true; | |
| 8127 |
9/18✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 4 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 4 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 4 times.
✗ Branch 17 not taken.
|
4 | LogErr(ERROR_LEVEL, ER_FAILED_TO_WRITE_TO_FILE, name, errno, |
| 8128 | my_strerror(errbuf, sizeof(errbuf), errno)); | ||
| 8129 | 4 | } | |
| 8130 | |||
| 8131 | /** | ||
| 8132 | Wait until we get a signal that the binary log has been updated. | ||
| 8133 | Applies to master only. | ||
| 8134 | |||
| 8135 | NOTES | ||
| 8136 | @param[in] timeout a pointer to a timespec; | ||
| 8137 | NULL means to wait w/o timeout. | ||
| 8138 | @retval 0 if got signalled on update | ||
| 8139 | @retval non-0 if wait timeout elapsed | ||
| 8140 | @note | ||
| 8141 | LOCK_binlog_end_pos must be taken before calling this function. | ||
| 8142 | LOCK_binlog_end_pos is being released while the thread is waiting. | ||
| 8143 | LOCK_binlog_end_pos is released by the caller. | ||
| 8144 | */ | ||
| 8145 | |||
| 8146 | 548799 | int MYSQL_BIN_LOG::wait_for_update(const struct timespec *timeout) { | |
| 8147 | 548799 | int ret = 0; | |
| 8148 |
1/2✓ Branch 0 taken 548799 times.
✗ Branch 1 not taken.
|
548799 | DBUG_TRACE; |
| 8149 | |||
| 8150 |
2/2✓ Branch 0 taken 153 times.
✓ Branch 1 taken 548646 times.
|
548799 | if (!timeout) |
| 8151 |
1/2✓ Branch 0 taken 153 times.
✗ Branch 1 not taken.
|
153 | mysql_cond_wait(&update_cond, &LOCK_binlog_end_pos); |
| 8152 | else | ||
| 8153 |
1/2✓ Branch 0 taken 548495 times.
✗ Branch 1 not taken.
|
548646 | ret = mysql_cond_timedwait(&update_cond, &LOCK_binlog_end_pos, |
| 8154 | const_cast<struct timespec *>(timeout)); | ||
| 8155 | 548648 | return ret; | |
| 8156 | 548648 | } | |
| 8157 | |||
| 8158 | /** | ||
| 8159 | Close the log file. | ||
| 8160 | |||
| 8161 | @param exiting Bitmask for one or more of the following bits: | ||
| 8162 | - LOG_CLOSE_INDEX : if we should close the index file | ||
| 8163 | - LOG_CLOSE_TO_BE_OPENED : if we intend to call open | ||
| 8164 | at once after close. | ||
| 8165 | - LOG_CLOSE_STOP_EVENT : write a 'stop' event to the log | ||
| 8166 | |||
| 8167 | @param need_lock_log If true, this function acquires LOCK_log; | ||
| 8168 | otherwise the caller should already have acquired it. | ||
| 8169 | |||
| 8170 | @param need_lock_index If true, this function acquires LOCK_index; | ||
| 8171 | otherwise the caller should already have acquired it. | ||
| 8172 | |||
| 8173 | @note | ||
| 8174 | One can do an open on the object at once after doing a close. | ||
| 8175 | The internal structures are not freed until cleanup() is called | ||
| 8176 | */ | ||
| 8177 | |||
| 8178 | 128341 | void MYSQL_BIN_LOG::close( | |
| 8179 | uint exiting, bool need_lock_log, | ||
| 8180 | bool need_lock_index) { // One can't set log_type here! | ||
| 8181 |
1/2✓ Branch 0 taken 128342 times.
✗ Branch 1 not taken.
|
128341 | DBUG_TRACE; |
| 8182 |
5/8✓ Branch 0 taken 128341 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 128342 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 128341 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
|
128342 | DBUG_PRINT("enter", ("exiting: %d", (int)exiting)); |
| 8183 |
2/2✓ Branch 0 taken 38258 times.
✓ Branch 1 taken 90084 times.
|
128342 | if (need_lock_log) |
| 8184 |
1/2✓ Branch 0 taken 38258 times.
✗ Branch 1 not taken.
|
38258 | mysql_mutex_lock(&LOCK_log); |
| 8185 | else | ||
| 8186 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 8187 | |||
| 8188 |
2/2✓ Branch 0 taken 77244 times.
✓ Branch 1 taken 51098 times.
|
128342 | if (atomic_log_state == LOG_OPENED) { |
| 8189 |
2/2✓ Branch 0 taken 16324 times.
✓ Branch 1 taken 60920 times.
|
77244 | if ((exiting & LOG_CLOSE_STOP_EVENT) != 0) { |
| 8190 | /** | ||
| 8191 | TODO(WL#7546): Change the implementation to Stop_event after write() is | ||
| 8192 | moved into libbinlogevents | ||
| 8193 | */ | ||
| 8194 |
1/2✓ Branch 0 taken 16324 times.
✗ Branch 1 not taken.
|
16324 | Stop_log_event s; |
| 8195 | // the checksumming rule for relay-log case is similar to Rotate | ||
| 8196 | 16324 | s.common_footer->checksum_alg = | |
| 8197 | 16324 | is_relay_log | |
| 8198 |
2/2✓ Branch 0 taken 8598 times.
✓ Branch 1 taken 7726 times.
|
16324 | ? relay_log_checksum_alg |
| 8199 | 7726 | : static_cast<enum_binlog_checksum_alg>(binlog_checksum_options); | |
| 8200 |
3/4✓ Branch 0 taken 8598 times.
✓ Branch 1 taken 7726 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8598 times.
|
16324 | assert(!is_relay_log || |
| 8201 | relay_log_checksum_alg != binary_log::BINLOG_CHECKSUM_ALG_UNDEF); | ||
| 8202 |
7/10✓ Branch 0 taken 16324 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16324 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 16324 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 16322 times.
✓ Branch 7 taken 2 times.
✓ Branch 8 taken 16322 times.
✓ Branch 9 taken 2 times.
|
16324 | if (!write_event_to_binlog(&s) && !m_binlog_file->flush()) |
| 8203 |
1/2✓ Branch 0 taken 16322 times.
✗ Branch 1 not taken.
|
16322 | update_binlog_end_pos(); |
| 8204 | 16324 | } | |
| 8205 | |||
| 8206 | /* The following update should not be done in relay log files */ | ||
| 8207 |
2/2✓ Branch 0 taken 24861 times.
✓ Branch 1 taken 52383 times.
|
77244 | if (!is_relay_log) { |
| 8208 | 24861 | my_off_t offset = BIN_LOG_HEADER_SIZE + FLAGS_OFFSET; | |
| 8209 | 24861 | uchar flags = 0; // clearing LOG_EVENT_BINLOG_IN_USE_F | |
| 8210 |
1/2✓ Branch 0 taken 24861 times.
✗ Branch 1 not taken.
|
24861 | (void)m_binlog_file->update(&flags, 1, offset); |
| 8211 | } | ||
| 8212 | |||
| 8213 |
6/8✓ Branch 0 taken 77241 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 77239 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 77239 times.
|
77244 | if (m_binlog_file->flush_and_sync() && !write_error) { |
| 8214 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | report_binlog_write_error(); |
| 8215 | } | ||
| 8216 | |||
| 8217 | /* | ||
| 8218 | LOCK_sync to guarantee that no thread is calling m_binlog_file | ||
| 8219 | to sync data to disk when another thread is closing m_binlog_file. | ||
| 8220 | */ | ||
| 8221 |
3/4✓ Branch 0 taken 24861 times.
✓ Branch 1 taken 52380 times.
✓ Branch 2 taken 24861 times.
✗ Branch 3 not taken.
|
77241 | if (!is_relay_log) mysql_mutex_lock(&LOCK_sync); |
| 8222 | 77241 | m_binlog_file->close(); | |
| 8223 |
3/4✓ Branch 0 taken 24861 times.
✓ Branch 1 taken 52383 times.
✓ Branch 2 taken 24861 times.
✗ Branch 3 not taken.
|
77244 | if (!is_relay_log) mysql_mutex_unlock(&LOCK_sync); |
| 8224 | |||
| 8225 | 77244 | atomic_log_state = | |
| 8226 |
2/2✓ Branch 0 taken 60898 times.
✓ Branch 1 taken 16346 times.
|
77244 | (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED; |
| 8227 |
1/2✓ Branch 0 taken 77244 times.
✗ Branch 1 not taken.
|
77244 | my_free(name); |
| 8228 | 77244 | name = nullptr; | |
| 8229 | } | ||
| 8230 | |||
| 8231 | /* | ||
| 8232 | The following test is needed even if is_open() is not set, as we may have | ||
| 8233 | called a not complete close earlier and the index file is still open. | ||
| 8234 | */ | ||
| 8235 | |||
| 8236 |
2/2✓ Branch 0 taken 38272 times.
✓ Branch 1 taken 90070 times.
|
128342 | if (need_lock_index) |
| 8237 |
1/2✓ Branch 0 taken 38272 times.
✗ Branch 1 not taken.
|
38272 | mysql_mutex_lock(&LOCK_index); |
| 8238 | else | ||
| 8239 | mysql_mutex_assert_owner(&LOCK_index); | ||
| 8240 | |||
| 8241 |
6/6✓ Branch 0 taken 99200 times.
✓ Branch 1 taken 29142 times.
✓ Branch 2 taken 77457 times.
✓ Branch 3 taken 21743 times.
✓ Branch 4 taken 77457 times.
✓ Branch 5 taken 50885 times.
|
128342 | if ((exiting & LOG_CLOSE_INDEX) && my_b_inited(&index_file)) { |
| 8242 |
1/2✓ Branch 0 taken 77457 times.
✗ Branch 1 not taken.
|
77457 | end_io_cache(&index_file); |
| 8243 |
6/8✓ Branch 0 taken 77457 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 77455 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 77455 times.
|
77457 | if (mysql_file_close(index_file.file, MYF(0)) < 0 && !write_error) { |
| 8244 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | report_binlog_write_error(); |
| 8245 | } | ||
| 8246 | } | ||
| 8247 | |||
| 8248 |
3/4✓ Branch 0 taken 38272 times.
✓ Branch 1 taken 90070 times.
✓ Branch 2 taken 38272 times.
✗ Branch 3 not taken.
|
128342 | if (need_lock_index) mysql_mutex_unlock(&LOCK_index); |
| 8249 | |||
| 8250 | 128342 | atomic_log_state = | |
| 8251 |
2/2✓ Branch 0 taken 90040 times.
✓ Branch 1 taken 38302 times.
|
128342 | (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED; |
| 8252 |
1/2✓ Branch 0 taken 128342 times.
✗ Branch 1 not taken.
|
128342 | my_free(name); |
| 8253 | 128342 | name = nullptr; | |
| 8254 | |||
| 8255 |
3/4✓ Branch 0 taken 38258 times.
✓ Branch 1 taken 90084 times.
✓ Branch 2 taken 38258 times.
✗ Branch 3 not taken.
|
128342 | if (need_lock_log) mysql_mutex_unlock(&LOCK_log); |
| 8256 | 128342 | } | |
| 8257 | |||
| 8258 | 1591671 | void MYSQL_BIN_LOG::harvest_bytes_written(Relay_log_info *rli, | |
| 8259 | bool need_log_space_lock) { | ||
| 8260 | #ifndef NDEBUG | ||
| 8261 | char buf1[22], buf2[22]; | ||
| 8262 | #endif | ||
| 8263 | |||
| 8264 |
1/2✓ Branch 0 taken 1591671 times.
✗ Branch 1 not taken.
|
1591671 | DBUG_TRACE; |
| 8265 |
2/2✓ Branch 0 taken 1591646 times.
✓ Branch 1 taken 25 times.
|
1591671 | if (need_log_space_lock) |
| 8266 |
1/2✓ Branch 0 taken 1591646 times.
✗ Branch 1 not taken.
|
1591646 | mysql_mutex_lock(&rli->log_space_lock); |
| 8267 | else | ||
| 8268 | mysql_mutex_assert_owner(&rli->log_space_lock); | ||
| 8269 | 1591671 | rli->log_space_total += bytes_written; | |
| 8270 |
3/12✓ Branch 0 taken 1591671 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1591671 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1591671 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
1591671 | DBUG_PRINT("info", |
| 8271 | ("relay_log_space: %s bytes_written: %s", | ||
| 8272 | llstr(rli->log_space_total, buf1), llstr(bytes_written, buf2))); | ||
| 8273 | 1591671 | bytes_written = 0; | |
| 8274 |
3/4✓ Branch 0 taken 1591646 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 1591645 times.
✗ Branch 3 not taken.
|
1591671 | if (need_log_space_lock) mysql_mutex_unlock(&rli->log_space_lock); |
| 8275 | 1591670 | } | |
| 8276 | |||
| 8277 | 213 | void MYSQL_BIN_LOG::set_max_size(ulong max_size_arg) { | |
| 8278 | /* | ||
| 8279 | We need to take locks, otherwise this may happen: | ||
| 8280 | new_file() is called, calls open(old_max_size), then before open() starts, | ||
| 8281 | set_max_size() sets max_size to max_size_arg, then open() starts and | ||
| 8282 | uses the old_max_size argument, so max_size_arg has been overwritten and | ||
| 8283 | it's like if the SET command was never run. | ||
| 8284 | */ | ||
| 8285 |
1/2✓ Branch 0 taken 213 times.
✗ Branch 1 not taken.
|
213 | DBUG_TRACE; |
| 8286 |
1/2✓ Branch 0 taken 213 times.
✗ Branch 1 not taken.
|
213 | mysql_mutex_lock(&LOCK_log); |
| 8287 |
2/2✓ Branch 0 taken 110 times.
✓ Branch 1 taken 103 times.
|
213 | if (is_open()) max_size = max_size_arg; |
| 8288 |
1/2✓ Branch 0 taken 213 times.
✗ Branch 1 not taken.
|
213 | mysql_mutex_unlock(&LOCK_log); |
| 8289 | 213 | } | |
| 8290 | |||
| 8291 | /****** transaction coordinator log for 2pc - binlog() based solution ******/ | ||
| 8292 | |||
| 8293 | /** | ||
| 8294 | @todo | ||
| 8295 | keep in-memory list of prepared transactions | ||
| 8296 | (add to list in log(), remove on unlog()) | ||
| 8297 | and copy it to the new binlog if rotated | ||
| 8298 | but let's check the behaviour of tc_log_page_waits first! | ||
| 8299 | */ | ||
| 8300 | |||
| 8301 | 9109 | int MYSQL_BIN_LOG::open_binlog(const char *opt_name) { | |
| 8302 | 9109 | LOG_INFO log_info; | |
| 8303 | 9109 | int error = 1; | |
| 8304 | 9109 | bool should_execute_ha_recover{false}; | |
| 8305 | |||
| 8306 | /* | ||
| 8307 | This function is used for 2pc transaction coordination. Hence, it | ||
| 8308 | is never used for relay logs. | ||
| 8309 | */ | ||
| 8310 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9109 times.
|
9109 | assert(!is_relay_log); |
| 8311 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 9109 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
9109 | assert(total_ha_2pc > 1 || (1 == total_ha_2pc && opt_bin_log)); |
| 8312 |
2/4✓ Branch 0 taken 9109 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9109 times.
✗ Branch 3 not taken.
|
9109 | assert(opt_name && opt_name[0]); |
| 8313 | |||
| 8314 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9109 times.
|
9109 | if (!my_b_inited(&index_file)) { |
| 8315 | /* There was a failure to open the index file, can't open the binlog */ | ||
| 8316 | ✗ | cleanup(); | |
| 8317 | ✗ | return 1; | |
| 8318 | } | ||
| 8319 | |||
| 8320 |
3/4✓ Branch 0 taken 9109 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 9107 times.
|
9109 | if (using_heuristic_recover()) { |
| 8321 | /* generate a new binlog to mask a corrupted one */ | ||
| 8322 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | mysql_mutex_lock(&LOCK_log); |
| 8323 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | open_binlog(opt_name, nullptr, max_binlog_size, false, |
| 8324 | true /*need_lock_index=true*/, true /*need_sid_lock=true*/, | ||
| 8325 | nullptr); | ||
| 8326 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | mysql_mutex_unlock(&LOCK_log); |
| 8327 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | cleanup(); |
| 8328 | 2 | return 1; | |
| 8329 | } | ||
| 8330 | |||
| 8331 |
3/4✓ Branch 0 taken 9107 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4189 times.
✓ Branch 3 taken 4918 times.
|
9107 | if ((error = find_log_pos(&log_info, NullS, true /*need_lock_index=true*/))) { |
| 8332 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4189 times.
|
4189 | if (error != LOG_INFO_EOF) |
| 8333 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_FIND_LOG_IN_INDEX, error); | |
| 8334 | else { | ||
| 8335 | 4189 | error = 0; | |
| 8336 | 4189 | should_execute_ha_recover = true; | |
| 8337 | } | ||
| 8338 | 4189 | goto err; | |
| 8339 | } | ||
| 8340 | |||
| 8341 | { | ||
| 8342 | 4918 | Log_event *ev = nullptr; | |
| 8343 | char log_name[FN_REFLEN]; | ||
| 8344 | 4918 | my_off_t valid_pos = 0; | |
| 8345 | 4918 | my_off_t binlog_size = 0; | |
| 8346 | |||
| 8347 | do { | ||
| 8348 |
1/2✓ Branch 0 taken 217497 times.
✗ Branch 1 not taken.
|
217497 | strmake(log_name, log_info.log_file_name, sizeof(log_name) - 1); |
| 8349 | } while ( | ||
| 8350 |
3/4✓ Branch 0 taken 217497 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 212579 times.
✓ Branch 3 taken 4918 times.
|
217497 | !(error = find_next_log(&log_info, true /*need_lock_index=true*/))); |
| 8351 | |||
| 8352 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4918 times.
|
4918 | if (error != LOG_INFO_EOF) { |
| 8353 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_FIND_LOG_IN_INDEX, error); | |
| 8354 | 3177 | goto err; | |
| 8355 | } | ||
| 8356 | |||
| 8357 |
1/2✓ Branch 0 taken 4918 times.
✗ Branch 1 not taken.
|
4918 | Binlog_file_reader binlog_file_reader(opt_source_verify_checksum); |
| 8358 |
3/4✓ Branch 0 taken 4918 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 4905 times.
|
4918 | if (binlog_file_reader.open(log_name)) { |
| 8359 |
9/18✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 13 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 13 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 13 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 13 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 13 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 13 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 13 times.
✗ Branch 17 not taken.
|
13 | LogErr(ERROR_LEVEL, ER_BINLOG_FILE_OPEN_FAILED, |
| 8360 | binlog_file_reader.get_error_str()); | ||
| 8361 | 13 | goto err; | |
| 8362 | } | ||
| 8363 | |||
| 8364 | /* | ||
| 8365 | If the binary log was not properly closed it means that the server | ||
| 8366 | may have crashed. In that case, we need to call | ||
| 8367 | binlog::Binlog_recovery::recover() | ||
| 8368 | to: | ||
| 8369 | |||
| 8370 | a) collect logged XIDs; | ||
| 8371 | b) complete the 2PC of the pending XIDs; | ||
| 8372 | c) collect the last valid position. | ||
| 8373 | |||
| 8374 | Therefore, we do need to iterate over the binary log, even if | ||
| 8375 | total_ha_2pc == 1, to find the last valid group of events written. | ||
| 8376 | Later we will take this value and truncate the log if need be. | ||
| 8377 | */ | ||
| 8378 |
2/4✓ Branch 0 taken 4905 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4905 times.
✗ Branch 3 not taken.
|
9810 | if ((ev = binlog_file_reader.read_event_object()) && |
| 8379 |
3/4✓ Branch 0 taken 4905 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1807 times.
✓ Branch 3 taken 3098 times.
|
9810 | ev->get_type_code() == binary_log::FORMAT_DESCRIPTION_EVENT && |
| 8380 |
2/2✓ Branch 0 taken 3098 times.
✓ Branch 1 taken 1807 times.
|
4905 | (ev->common_header->flags & LOG_EVENT_BINLOG_IN_USE_F || |
| 8381 |
2/4✓ Branch 0 taken 3098 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3098 times.
|
3098 | DBUG_EVALUATE_IF("eval_force_bin_log_recovery", true, false))) { |
| 8382 |
8/16✓ Branch 0 taken 1807 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1807 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1807 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1807 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1807 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1807 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1807 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1807 times.
✗ Branch 15 not taken.
|
1807 | LogErr(INFORMATION_LEVEL, ER_BINLOG_RECOVERING_AFTER_CRASH_USING, |
| 8383 | opt_name); | ||
| 8384 |
1/2✓ Branch 0 taken 1807 times.
✗ Branch 1 not taken.
|
1807 | binlog::Binlog_recovery bl_recovery{binlog_file_reader}; |
| 8385 | 1807 | error = bl_recovery // | |
| 8386 |
1/2✓ Branch 0 taken 1807 times.
✗ Branch 1 not taken.
|
1807 | .recover() // |
| 8387 |
1/2✓ Branch 0 taken 1807 times.
✗ Branch 1 not taken.
|
1807 | .has_failures(); |
| 8388 |
1/2✓ Branch 0 taken 1807 times.
✗ Branch 1 not taken.
|
1807 | valid_pos = bl_recovery.get_valid_pos(); |
| 8389 |
1/2✓ Branch 0 taken 1807 times.
✗ Branch 1 not taken.
|
1807 | binlog_size = binlog_file_reader.ifile()->length(); |
| 8390 |
2/2✓ Branch 0 taken 66 times.
✓ Branch 1 taken 1741 times.
|
1807 | if (error) { |
| 8391 |
3/4✓ Branch 0 taken 66 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 48 times.
|
66 | if (bl_recovery.is_binlog_malformed()) |
| 8392 |
9/18✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 18 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 18 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 18 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 18 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 18 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 18 times.
✗ Branch 17 not taken.
|
18 | LogErr(ERROR_LEVEL, ER_BINLOG_CRASH_RECOVERY_MALFORMED_LOG, log_name, |
| 8393 | valid_pos, binlog_file_reader.position(), | ||
| 8394 | bl_recovery.get_failure_message().data()); | ||
| 8395 |
3/4✓ Branch 0 taken 66 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 48 times.
✓ Branch 3 taken 18 times.
|
66 | if (bl_recovery.has_engine_recovery_failed()) |
| 8396 |
8/16✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 48 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 48 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 48 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 48 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 48 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 48 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 48 times.
✗ Branch 15 not taken.
|
48 | LogErr(ERROR_LEVEL, ER_BINLOG_CRASH_RECOVERY_ERROR_RETURNED_SE); |
| 8397 | } | ||
| 8398 | 1807 | } else | |
| 8399 | 3098 | should_execute_ha_recover = true; | |
| 8400 | |||
| 8401 |
1/2✓ Branch 0 taken 4905 times.
✗ Branch 1 not taken.
|
4905 | delete ev; |
| 8402 | |||
| 8403 |
2/2✓ Branch 0 taken 3164 times.
✓ Branch 1 taken 1741 times.
|
4905 | if (error) goto err; |
| 8404 | |||
| 8405 | /* Trim the crashed binlog file to last valid transaction | ||
| 8406 | or event (non-transaction) base on valid_pos. */ | ||
| 8407 |
1/2✓ Branch 0 taken 1741 times.
✗ Branch 1 not taken.
|
1741 | if (valid_pos > 0) { |
| 8408 | std::unique_ptr<Binlog_ofile> ofile( | ||
| 8409 |
1/2✓ Branch 0 taken 1741 times.
✗ Branch 1 not taken.
|
1741 | Binlog_ofile::open_existing(key_file_binlog, log_name, MYF(MY_WME))); |
| 8410 | |||
| 8411 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1741 times.
|
1741 | if (!ofile) { |
| 8412 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_OPEN_CRASHED_BINLOG); | |
| 8413 | ✗ | return -1; | |
| 8414 | } | ||
| 8415 | |||
| 8416 | /* Change binlog file size to valid_pos */ | ||
| 8417 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1735 times.
|
1741 | if (valid_pos < binlog_size) { |
| 8418 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
|
6 | if (ofile->truncate(valid_pos)) { |
| 8419 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_CANT_TRIM_CRASHED_BINLOG); | |
| 8420 | ✗ | return -1; | |
| 8421 | } | ||
| 8422 |
8/16✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6 times.
✗ Branch 15 not taken.
|
6 | LogErr(INFORMATION_LEVEL, ER_BINLOG_CRASHED_BINLOG_TRIMMED, log_name, |
| 8423 | binlog_size, valid_pos, valid_pos); | ||
| 8424 | } | ||
| 8425 | |||
| 8426 | /* Clear LOG_EVENT_BINLOG_IN_USE_F */ | ||
| 8427 | 1741 | uchar flags = 0; | |
| 8428 |
2/4✓ Branch 0 taken 1741 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1741 times.
|
1741 | if (ofile->update(&flags, 1, BIN_LOG_HEADER_SIZE + FLAGS_OFFSET)) { |
| 8429 | ✗ | LogErr(ERROR_LEVEL, | |
| 8430 | ER_BINLOG_CANT_CLEAR_IN_USE_FLAG_FOR_CRASHED_BINLOG); | ||
| 8431 | ✗ | return -1; | |
| 8432 | } | ||
| 8433 |
1/2✓ Branch 0 taken 1741 times.
✗ Branch 1 not taken.
|
1741 | } // end if (valid_pos > 0) |
| 8434 |
2/3✓ Branch 0 taken 1741 times.
✓ Branch 1 taken 3177 times.
✗ Branch 2 not taken.
|
4918 | } |
| 8435 | |||
| 8436 | 9107 | err: | |
| 8437 |
2/2✓ Branch 0 taken 7287 times.
✓ Branch 1 taken 1820 times.
|
9107 | if (should_execute_ha_recover) { |
| 8438 |
1/2✓ Branch 0 taken 7287 times.
✗ Branch 1 not taken.
|
7287 | error = ha_recover(); |
| 8439 |
1/18✗ Branch 0 not taken.
✓ Branch 1 taken 7287 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
|
7287 | if (error) LogErr(ERROR_LEVEL, ER_BINLOG_CRASH_RECOVERY_ERROR_RETURNED_SE); |
| 8440 | } | ||
| 8441 | 9107 | return error; | |
| 8442 | } | ||
| 8443 | |||
| 8444 | /** | ||
| 8445 | Truncate the active relay log file in the specified position. | ||
| 8446 | |||
| 8447 | @param mi Master_info of the channel going to truncate the relay log file. | ||
| 8448 | @param truncate_pos The position to truncate the active relay log file. | ||
| 8449 | @return False on success and true on failure. | ||
| 8450 | */ | ||
| 8451 | 6 | bool MYSQL_BIN_LOG::truncate_relaylog_file(Master_info *mi, | |
| 8452 | my_off_t truncate_pos) { | ||
| 8453 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | DBUG_TRACE; |
| 8454 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | assert(is_relay_log); |
| 8455 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 8456 | 6 | Relay_log_info *rli = mi->rli; | |
| 8457 | 6 | bool error = false; | |
| 8458 | |||
| 8459 | /* | ||
| 8460 | If the relay log was closed by an error (binlog_error_action=IGNORE_ERROR) | ||
| 8461 | this truncate function should produce no result as the relay log is already | ||
| 8462 | in really bad shape. | ||
| 8463 | */ | ||
| 8464 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (!is_open()) { |
| 8465 | ✗ | return false; | |
| 8466 | } | ||
| 8467 | |||
| 8468 | 6 | my_off_t relaylog_file_size = m_binlog_file->position(); | |
| 8469 | |||
| 8470 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
6 | if (truncate_pos > 0 && truncate_pos < relaylog_file_size) { |
| 8471 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
|
6 | if (m_binlog_file->truncate(truncate_pos)) { |
| 8472 | ✗ | mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE, | |
| 8473 | ✗ | ER_THD(current_thd, ER_SLAVE_RELAY_LOG_WRITE_FAILURE), | |
| 8474 | "failed to truncate relay log file"); | ||
| 8475 | ✗ | error = true; | |
| 8476 | } else { | ||
| 8477 |
8/16✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 6 times.
✗ Branch 15 not taken.
|
6 | LogErr(INFORMATION_LEVEL, ER_SLAVE_RELAY_LOG_TRUNCATE_INFO, log_file_name, |
| 8478 | relaylog_file_size, truncate_pos); | ||
| 8479 | |||
| 8480 | // Re-init the SQL thread IO_CACHE | ||
| 8481 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
|
6 | assert(strcmp(rli->get_event_relay_log_name(), log_file_name) || |
| 8482 | rli->get_event_relay_log_pos() <= truncate_pos); | ||
| 8483 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | rli->notify_relay_log_truncated(); |
| 8484 | } | ||
| 8485 | } | ||
| 8486 | 6 | return error; | |
| 8487 | 6 | } | |
| 8488 | |||
| 8489 | /** This is called on shutdown, after ha_panic. */ | ||
| 8490 | ✗ | void MYSQL_BIN_LOG::close() {} | |
| 8491 | |||
| 8492 | /* | ||
| 8493 | Prepare the transaction in the transaction coordinator. | ||
| 8494 | |||
| 8495 | This function will prepare the transaction in the storage engines | ||
| 8496 | (by calling @c ha_prepare_low) what will write a prepare record | ||
| 8497 | to the log buffers. | ||
| 8498 | |||
| 8499 | @retval 0 success | ||
| 8500 | @retval 1 error | ||
| 8501 | */ | ||
| 8502 | 4974096 | int MYSQL_BIN_LOG::prepare(THD *thd, bool all) { | |
| 8503 |
1/2✓ Branch 0 taken 4974163 times.
✗ Branch 1 not taken.
|
4974096 | DBUG_TRACE; |
| 8504 | |||
| 8505 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4974163 times.
|
4974163 | assert(opt_bin_log); |
| 8506 | |||
| 8507 | /* | ||
| 8508 | Set HA_IGNORE_DURABILITY to not flush the prepared record of the | ||
| 8509 | transaction to the log of storage engine (for example, InnoDB | ||
| 8510 | redo log) during the prepare phase. So that we can flush prepared | ||
| 8511 | records of transactions to the log of storage engine in a group | ||
| 8512 | right before flushing them to binary log during binlog group | ||
| 8513 | commit flush stage. Reset to HA_REGULAR_DURABILITY at the | ||
| 8514 | beginning of parsing next command. | ||
| 8515 | */ | ||
| 8516 | 4974163 | thd->durability_property = HA_IGNORE_DURABILITY; | |
| 8517 | |||
| 8518 |
2/4✓ Branch 0 taken 4974154 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4974169 times.
✗ Branch 3 not taken.
|
4974163 | CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_prepare_in_engines"); |
| 8519 |
1/2✓ Branch 0 taken 4974122 times.
✗ Branch 1 not taken.
|
4974176 | int error = ha_prepare_low(thd, all); |
| 8520 | |||
| 8521 |
2/4✓ Branch 0 taken 4974157 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4974157 times.
✗ Branch 3 not taken.
|
4974122 | CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("after_ha_prepare_low"); |
| 8522 | // Invoke `commit` if we're dealing with `XA PREPARE` in order to use BCG | ||
| 8523 | // to write the event to file. | ||
| 8524 |
10/12✓ Branch 0 taken 4973830 times.
✓ Branch 1 taken 308 times.
✓ Branch 2 taken 536650 times.
✓ Branch 3 taken 4437180 times.
✓ Branch 4 taken 536648 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 574 times.
✓ Branch 7 taken 536074 times.
✓ Branch 8 taken 574 times.
✓ Branch 9 taken 4973562 times.
✓ Branch 10 taken 571 times.
✗ Branch 11 not taken.
|
4974138 | if (!error && all && is_xa_prepare(thd)) return this->commit(thd, true); |
| 8525 | |||
| 8526 | 4973562 | return error; | |
| 8527 | 4974133 | } | |
| 8528 | |||
| 8529 | /** | ||
| 8530 | Commit the transaction in the transaction coordinator. | ||
| 8531 | |||
| 8532 | This function will commit the sessions transaction in the binary log | ||
| 8533 | and in the storage engines (by calling @c ha_commit_low). If the | ||
| 8534 | transaction was successfully logged (or not successfully unlogged) | ||
| 8535 | but the commit in the engines did not succeed, there is a risk of | ||
| 8536 | inconsistency between the engines and the binary log. | ||
| 8537 | |||
| 8538 | For binary log group commit, the commit is separated into three | ||
| 8539 | parts: | ||
| 8540 | |||
| 8541 | 1. First part consists of filling the necessary caches and | ||
| 8542 | finalizing them (if they need to be finalized). After this, | ||
| 8543 | nothing is added to any of the caches. | ||
| 8544 | |||
| 8545 | 2. Second part execute an ordered flush and commit. This will be | ||
| 8546 | done using the group commit functionality in ordered_commit. | ||
| 8547 | |||
| 8548 | 3. Third part checks any errors resulting from the ordered commit | ||
| 8549 | and handles them appropriately. | ||
| 8550 | |||
| 8551 | @retval RESULT_SUCCESS success | ||
| 8552 | @retval RESULT_ABORTED error, transaction was neither logged nor committed | ||
| 8553 | @retval RESULT_INCONSISTENT error, transaction was logged but not committed | ||
| 8554 | */ | ||
| 8555 | 31168391 | TC_LOG::enum_result MYSQL_BIN_LOG::commit(THD *thd, bool all) { | |
| 8556 |
1/2✓ Branch 0 taken 31173630 times.
✗ Branch 1 not taken.
|
31168391 | DBUG_TRACE; |
| 8557 |
8/14✓ Branch 0 taken 31172217 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31172816 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 636 times.
✓ Branch 5 taken 31172180 times.
✓ Branch 6 taken 636 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 636 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 636 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 636 times.
✗ Branch 13 not taken.
|
31173630 | DBUG_PRINT("info", |
| 8558 | ("query='%s'", thd == current_thd ? thd->query().str : nullptr)); | ||
| 8559 | 31172816 | Transaction_ctx *trn_ctx = thd->get_transaction(); | |
| 8560 | #ifdef WITH_WSREP | ||
| 8561 | my_xid xid; | ||
| 8562 | 31170918 | const XID *curr_xid = trn_ctx->xid_state()->get_xid(); | |
| 8563 |
3/4✓ Branch 0 taken 31169905 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 267649 times.
✓ Branch 3 taken 30902256 times.
|
31170609 | if (wsrep_is_wsrep_xid(curr_xid)) { |
| 8564 |
1/2✓ Branch 0 taken 267658 times.
✗ Branch 1 not taken.
|
267649 | xid = wsrep_xid_seqno(*curr_xid).get(); |
| 8565 | } else { | ||
| 8566 |
1/2✓ Branch 0 taken 30903241 times.
✗ Branch 1 not taken.
|
30902256 | xid = curr_xid->get_my_xid(); |
| 8567 | } | ||
| 8568 | #else | ||
| 8569 | my_xid xid = trn_ctx->xid_state()->get_xid()->get_my_xid(); | ||
| 8570 | #endif /* WITH_WSREP */ | ||
| 8571 | 31170902 | bool stmt_stuff_logged = false; | |
| 8572 | 31170902 | bool trx_stuff_logged = false; | |
| 8573 |
1/2✓ Branch 0 taken 31171526 times.
✗ Branch 1 not taken.
|
31170902 | bool skip_commit = is_loggable_xa_prepare(thd); |
| 8574 | 31171526 | bool is_atomic_ddl = false; | |
| 8575 | 31171526 | auto xs = thd->get_transaction()->xid_state(); | |
| 8576 | 31168567 | raii::Sentry<> reset_detached_guard{[&]() -> void { | |
| 8577 | // XID_STATE may have been used to hold metadata for a detached transaction. | ||
| 8578 | // In that case, we need to reset it. | ||
| 8579 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31169504 times.
|
31168567 | if (xs->is_detached()) xs->reset(); |
| 8580 |
1/2✓ Branch 0 taken 31170377 times.
✗ Branch 1 not taken.
|
31171887 | }}; |
| 8581 | |||
| 8582 |
2/2✓ Branch 0 taken 1086 times.
✓ Branch 1 taken 31169411 times.
|
31170497 | if (thd->lex->sql_command == |
| 8583 | SQLCOM_XA_COMMIT) { // XA commit must be written to the binary log prior | ||
| 8584 | // to retrieving cache manager | ||
| 8585 |
2/4✓ Branch 0 taken 1086 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1086 times.
|
1086 | if (this->write_xa_to_cache(thd)) return RESULT_ABORTED; |
| 8586 | } | ||
| 8587 | |||
| 8588 |
1/2✓ Branch 0 taken 31170915 times.
✗ Branch 1 not taken.
|
31170497 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd); |
| 8589 |
7/10✓ Branch 0 taken 31170423 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31170877 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 628 times.
✓ Branch 5 taken 31170249 times.
✓ Branch 6 taken 300 times.
✓ Branch 7 taken 328 times.
✓ Branch 8 taken 703 times.
✗ Branch 9 not taken.
|
31170915 | DBUG_PRINT("enter", ("thd: 0x%llx, all: %s, xid: %llu, cache_mngr: 0x%llx", |
| 8590 | (ulonglong)thd, YESNO(all), (ulonglong)xid, | ||
| 8591 | (ulonglong)cache_mngr)); | ||
| 8592 | |||
| 8593 | /* | ||
| 8594 | No cache manager means nothing to log, but we still have to commit | ||
| 8595 | the transaction. | ||
| 8596 | */ | ||
| 8597 |
2/2✓ Branch 0 taken 10545523 times.
✓ Branch 1 taken 20625429 times.
|
31170952 | if (cache_mngr == nullptr) { |
| 8598 |
7/8✓ Branch 0 taken 10545422 times.
✓ Branch 1 taken 101 times.
✓ Branch 2 taken 10546077 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 10546074 times.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 10546175 times.
|
10545523 | if (!skip_commit && trx_coordinator::commit_in_engines(thd, all)) |
| 8599 | 3 | return RESULT_ABORTED; | |
| 8600 | 10546175 | return RESULT_SUCCESS; | |
| 8601 | } | ||
| 8602 | |||
| 8603 | /* | ||
| 8604 | Reset binlog_snapshot_% variables for the current connection so that the | ||
| 8605 | current coordinates are shown after committing a consistent snapshot | ||
| 8606 | transaction. | ||
| 8607 | */ | ||
| 8608 |
2/2✓ Branch 0 taken 2032173 times.
✓ Branch 1 taken 18593256 times.
|
20625429 | if (all) { |
| 8609 |
1/2✓ Branch 0 taken 2032241 times.
✗ Branch 1 not taken.
|
2032173 | mysql_mutex_lock(&thd->LOCK_thd_data); |
| 8610 | 2032241 | cache_mngr->drop_consistent_snapshot(); | |
| 8611 |
1/2✓ Branch 0 taken 2032207 times.
✗ Branch 1 not taken.
|
2032345 | mysql_mutex_unlock(&thd->LOCK_thd_data); |
| 8612 | } | ||
| 8613 | |||
| 8614 | 20625463 | Transaction_ctx::enum_trx_scope trx_scope = | |
| 8615 |
2/2✓ Branch 0 taken 2032391 times.
✓ Branch 1 taken 18593072 times.
|
20625463 | all ? Transaction_ctx::SESSION : Transaction_ctx::STMT; |
| 8616 | |||
| 8617 |
8/12✓ Branch 0 taken 20625688 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20625894 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 616 times.
✓ Branch 5 taken 20625278 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 616 times.
✓ Branch 8 taken 583 times.
✓ Branch 9 taken 33 times.
✓ Branch 10 taken 616 times.
✗ Branch 11 not taken.
|
20625463 | DBUG_PRINT("debug", ("in_transaction: %s, no_2pc: %s, rw_ha_count: %d", |
| 8618 | YESNO(thd->in_multi_stmt_transaction_mode()), | ||
| 8619 | YESNO(trn_ctx->no_2pc(trx_scope)), | ||
| 8620 | trn_ctx->rw_ha_count(trx_scope))); | ||
| 8621 |
10/14✓ Branch 0 taken 20625579 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20625818 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 616 times.
✓ Branch 5 taken 20625202 times.
✓ Branch 6 taken 616 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 437 times.
✓ Branch 9 taken 179 times.
✓ Branch 10 taken 24 times.
✓ Branch 11 taken 592 times.
✓ Branch 12 taken 616 times.
✗ Branch 13 not taken.
|
20625894 | DBUG_PRINT("debug", |
| 8622 | ("all.cannot_safely_rollback(): %s, trx_cache_empty: %s", | ||
| 8623 | YESNO(trn_ctx->cannot_safely_rollback(Transaction_ctx::SESSION)), | ||
| 8624 | YESNO(cache_mngr->trx_cache.is_binlog_empty()))); | ||
| 8625 |
9/14✓ Branch 0 taken 20625608 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 20625859 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 616 times.
✓ Branch 5 taken 20625243 times.
✓ Branch 6 taken 616 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 591 times.
✓ Branch 9 taken 25 times.
✓ Branch 10 taken 10 times.
✓ Branch 11 taken 606 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
20625818 | DBUG_PRINT("debug", |
| 8626 | ("stmt.cannot_safely_rollback(): %s, stmt_cache_empty: %s", | ||
| 8627 | YESNO(trn_ctx->cannot_safely_rollback(Transaction_ctx::STMT)), | ||
| 8628 | YESNO(cache_mngr->stmt_cache.is_binlog_empty()))); | ||
| 8629 | |||
| 8630 | /* | ||
| 8631 | If there are no handlertons registered, there is nothing to | ||
| 8632 | commit. Note that DDLs are written earlier in this case (inside | ||
| 8633 | binlog_query). | ||
| 8634 | |||
| 8635 | TODO: This can be a problem in those cases that there are no | ||
| 8636 | handlertons registered. DDLs are one example, but the other case | ||
| 8637 | is MyISAM. In this case, we could register a dummy handlerton to | ||
| 8638 | trigger the commit. | ||
| 8639 | |||
| 8640 | Any statement that requires logging will call binlog_query before | ||
| 8641 | trans_commit_stmt, so an alternative is to use the condition | ||
| 8642 | "binlog_query called or stmt.ha_list != 0". | ||
| 8643 | */ | ||
| 8644 |
6/6✓ Branch 0 taken 18592893 times.
✓ Branch 1 taken 2032186 times.
✓ Branch 2 taken 12772973 times.
✓ Branch 3 taken 5820198 times.
✓ Branch 4 taken 12687540 times.
✓ Branch 5 taken 7938456 times.
|
33398691 | if (!all && !trn_ctx->is_active(trx_scope) && |
| 8645 |
3/4✓ Branch 0 taken 12773612 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12687516 times.
✓ Branch 3 taken 86096 times.
|
12772973 | cache_mngr->stmt_cache.is_binlog_empty()) |
| 8646 | 12687540 | return RESULT_SUCCESS; | |
| 8647 | |||
| 8648 |
3/4✓ Branch 0 taken 7938632 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 489226 times.
✓ Branch 3 taken 7449406 times.
|
7938456 | if (!cache_mngr->stmt_cache.is_binlog_empty()) { |
| 8649 | /* | ||
| 8650 | Commit parent identification of non-transactional query has | ||
| 8651 | been deferred until now, except for the mixed transaction case. | ||
| 8652 | */ | ||
| 8653 |
1/2✓ Branch 0 taken 489122 times.
✗ Branch 1 not taken.
|
489226 | trn_ctx->store_commit_parent( |
| 8654 | m_dependency_tracker.get_max_committed_timestamp()); | ||
| 8655 |
2/4✓ Branch 0 taken 489311 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 489311 times.
|
489083 | if (cache_mngr->stmt_cache.finalize(thd)) return RESULT_ABORTED; |
| 8656 | 489311 | stmt_stuff_logged = true; | |
| 8657 | } | ||
| 8658 | |||
| 8659 | /* | ||
| 8660 | We commit the transaction if: | ||
| 8661 | - We are not in a transaction and committing a statement, or | ||
| 8662 | - We are in a transaction and a full transaction is committed. | ||
| 8663 | Otherwise, we accumulate the changes. | ||
| 8664 | */ | ||
| 8665 |
8/10✓ Branch 0 taken 7938702 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5225048 times.
✓ Branch 3 taken 2713654 times.
✓ Branch 4 taken 5225021 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2100573 times.
✓ Branch 7 taken 3124448 times.
✓ Branch 8 taken 2100573 times.
✓ Branch 9 taken 5838102 times.
|
10039290 | if (!cache_mngr->trx_cache.is_binlog_empty() && ending_trans(thd, all) && |
| 8666 |
2/2✓ Branch 0 taken 2100572 times.
✓ Branch 1 taken 1 times.
|
2100573 | !trx_stuff_logged) { |
| 8667 | const bool real_trans = | ||
| 8668 |
3/4✓ Branch 0 taken 1509662 times.
✓ Branch 1 taken 590911 times.
✓ Branch 2 taken 1509662 times.
✗ Branch 3 not taken.
|
2100573 | (all || !trn_ctx->is_active(Transaction_ctx::SESSION)); |
| 8669 | |||
| 8670 |
1/2✓ Branch 0 taken 2100568 times.
✗ Branch 1 not taken.
|
2100573 | bool one_phase = get_xa_opt(thd) == XA_ONE_PHASE; |
| 8671 |
1/2✓ Branch 0 taken 2100577 times.
✗ Branch 1 not taken.
|
2100568 | bool is_loggable_xa = is_loggable_xa_prepare(thd); |
| 8672 | |||
| 8673 | /* | ||
| 8674 | Log and finalize transaction cache regarding XA PREPARE/XA COMMIT ONE | ||
| 8675 | PHASE if one of the following statements is true: | ||
| 8676 | - If it is a loggable XA transaction in prepare state; | ||
| 8677 | - If it is a transaction being committed with 'XA COMMIT ONE PHASE', | ||
| 8678 | statement and is not an empty transaction when GTID_NEXT is set to a | ||
| 8679 | manual GTID. | ||
| 8680 | |||
| 8681 | For other XA COMMIT ONE PHASE statements that already have been finalized | ||
| 8682 | or are finalizing empty transactions when GTID_NEXT is set to a manual | ||
| 8683 | GTID, just let the execution flow get into the final 'else' branch and log | ||
| 8684 | a final 'COMMIT;' statement. | ||
| 8685 | */ | ||
| 8686 |
4/4✓ Branch 0 taken 2100038 times.
✓ Branch 1 taken 539 times.
✓ Branch 2 taken 638 times.
✓ Branch 3 taken 2099939 times.
|
4200615 | if (is_loggable_xa || // XA transaction in prepare state |
| 8687 |
3/4✓ Branch 0 taken 102 times.
✓ Branch 1 taken 2099936 times.
✓ Branch 2 taken 102 times.
✗ Branch 3 not taken.
|
2100038 | (thd->lex->sql_command == SQLCOM_XA_COMMIT && // Is a 'XA COMMIT |
| 8688 | 102 | one_phase && // ONE PHASE' | |
| 8689 |
1/2✓ Branch 0 taken 102 times.
✗ Branch 1 not taken.
|
102 | xs != nullptr && // and it has not yet |
| 8690 |
1/2✓ Branch 0 taken 102 times.
✗ Branch 1 not taken.
|
102 | !xs->is_binlogged() && // been logged |
| 8691 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 87 times.
|
102 | (thd->owned_gtid.sidno <= 0 || // and GTID_NEXT is NOT set to a |
| 8692 | // manual GTID | ||
| 8693 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 3 times.
|
15 | !xs->has_state(XID_STATE::XA_NOTR)))) // and the transaction is NOT |
| 8694 | // empty and NOT finalized in | ||
| 8695 | // 'trans_xa_commit' | ||
| 8696 | { | ||
| 8697 | /* The prepare phase of XA transaction two phase logging. */ | ||
| 8698 | 638 | int err = 0; | |
| 8699 | |||
| 8700 |
3/4✓ Branch 0 taken 99 times.
✓ Branch 1 taken 539 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 99 times.
|
638 | assert(thd->lex->sql_command != SQLCOM_XA_COMMIT || one_phase); |
| 8701 | |||
| 8702 |
1/2✓ Branch 0 taken 638 times.
✗ Branch 1 not taken.
|
638 | XA_prepare_log_event end_evt(thd, xs->get_xid(), one_phase); |
| 8703 | |||
| 8704 |
3/4✓ Branch 0 taken 539 times.
✓ Branch 1 taken 99 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 539 times.
|
638 | assert(!is_loggable_xa || skip_commit); |
| 8705 | |||
| 8706 |
1/2✓ Branch 0 taken 638 times.
✗ Branch 1 not taken.
|
638 | err = cache_mngr->trx_cache.finalize(thd, &end_evt, xs); |
| 8707 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 638 times.
|
638 | if (err) return RESULT_ABORTED; |
| 8708 |
2/2✓ Branch 0 taken 539 times.
✓ Branch 1 taken 99 times.
|
638 | if (is_loggable_xa) |
| 8709 |
3/4✓ Branch 0 taken 539 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 533 times.
|
539 | if (DBUG_EVALUATE_IF("simulate_xa_prepare_failure_in_cache_finalize", |
| 8710 | true, false)) | ||
| 8711 | 6 | return RESULT_ABORTED; | |
| 8712 |
2/2✓ Branch 0 taken 632 times.
✓ Branch 1 taken 6 times.
|
638 | } |
| 8713 | /* | ||
| 8714 | If is atomic DDL, finalize cache for DDL and no further logging is needed. | ||
| 8715 | */ | ||
| 8716 |
2/2✓ Branch 0 taken 317939 times.
✓ Branch 1 taken 1781994 times.
|
2099939 | else if ((is_atomic_ddl = cache_mngr->trx_cache.has_xid())) { |
| 8717 |
2/4✓ Branch 0 taken 317939 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 317939 times.
|
317939 | if (cache_mngr->trx_cache.finalize(thd, nullptr)) return RESULT_ABORTED; |
| 8718 | } | ||
| 8719 | /* | ||
| 8720 | We are committing a 2PC transaction if it is a "real" transaction | ||
| 8721 | and has an XID assigned (because some handlerton registered). A | ||
| 8722 | transaction is "real" if either 'all' is true or | ||
| 8723 | 'trn_ctx->is_active(Transaction_ctx::SESSION)' is not true. | ||
| 8724 | |||
| 8725 | Note: This is kind of strange since registering the binlog | ||
| 8726 | handlerton will then make the transaction 2PC, which is not really | ||
| 8727 | true. This occurs for example if a MyISAM statement is executed | ||
| 8728 | with row-based replication on. | ||
| 8729 | */ | ||
| 8730 |
8/8✓ Branch 0 taken 1781990 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 1751905 times.
✓ Branch 3 taken 30085 times.
✓ Branch 4 taken 1722016 times.
✓ Branch 5 taken 29892 times.
✓ Branch 6 taken 1722014 times.
✓ Branch 7 taken 59983 times.
|
3504010 | else if (real_trans && xid && trn_ctx->rw_ha_count(trx_scope) > 1 && |
| 8731 |
1/2✓ Branch 0 taken 1722017 times.
✗ Branch 1 not taken.
|
1722016 | !trn_ctx->no_2pc(trx_scope)) { |
| 8732 |
1/2✓ Branch 0 taken 1722013 times.
✗ Branch 1 not taken.
|
1722014 | Xid_log_event end_evt(thd, xid); |
| 8733 |
2/4✓ Branch 0 taken 1722021 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1722021 times.
|
1722013 | if (cache_mngr->trx_cache.finalize(thd, &end_evt)) return RESULT_ABORTED; |
| 8734 |
1/2✓ Branch 0 taken 1722005 times.
✗ Branch 1 not taken.
|
1722021 | } |
| 8735 | /* | ||
| 8736 | No further action needed and no special case applies, log a final | ||
| 8737 | 'COMMIT' statement and finalize the transaction cache. | ||
| 8738 | |||
| 8739 | Empty transactions finalized with 'XA COMMIT ONE PHASE' will be covered | ||
| 8740 | by this branch. | ||
| 8741 | */ | ||
| 8742 | else { | ||
| 8743 | Query_log_event end_evt(thd, STRING_WITH_LEN("COMMIT"), true, false, true, | ||
| 8744 |
1/2✓ Branch 0 taken 59980 times.
✗ Branch 1 not taken.
|
59983 | 0, true); |
| 8745 |
2/4✓ Branch 0 taken 59980 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 59980 times.
|
59980 | if (cache_mngr->trx_cache.finalize(thd, &end_evt)) return RESULT_ABORTED; |
| 8746 |
1/2✓ Branch 0 taken 59980 times.
✗ Branch 1 not taken.
|
59980 | } |
| 8747 | 2100556 | trx_stuff_logged = true; | |
| 8748 | } | ||
| 8749 | |||
| 8750 | /* | ||
| 8751 | This is part of the stmt rollback. | ||
| 8752 | */ | ||
| 8753 |
3/4✓ Branch 0 taken 5906098 times.
✓ Branch 1 taken 2032560 times.
✓ Branch 2 taken 5906433 times.
✗ Branch 3 not taken.
|
7938658 | if (!all) cache_mngr->trx_cache.set_prev_position(MY_OFF_T_UNDEF); |
| 8754 | |||
| 8755 | /* | ||
| 8756 | Now all the events are written to the caches, so we will commit | ||
| 8757 | the transaction in the engines. This is done using the group | ||
| 8758 | commit logic in ordered_commit, which will return when the | ||
| 8759 | transaction is committed. | ||
| 8760 | |||
| 8761 | If the commit in the engines fail, we still have something logged | ||
| 8762 | to the binary log so we have to report this as a "bad" failure | ||
| 8763 | (failed to commit, but logged something). | ||
| 8764 | */ | ||
| 8765 |
4/4✓ Branch 0 taken 7449257 times.
✓ Branch 1 taken 489736 times.
✓ Branch 2 taken 2095774 times.
✓ Branch 3 taken 5353483 times.
|
7938993 | if (stmt_stuff_logged || trx_stuff_logged) { |
| 8766 |
2/4✓ Branch 0 taken 2584957 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2585028 times.
✗ Branch 3 not taken.
|
2585510 | CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_invoke_before_commit_hook"); |
| 8767 |
6/10✓ Branch 0 taken 2584845 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2481140 times.
✓ Branch 3 taken 103705 times.
✓ Branch 4 taken 103738 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 103762 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 103804 times.
✗ Branch 9 not taken.
|
2584989 | if (RUN_HOOK( |
| 8768 | transaction, before_commit, | ||
| 8769 | (thd, all, thd_get_cache_mngr(thd)->get_trx_cache(), | ||
| 8770 | thd_get_cache_mngr(thd)->get_stmt_cache(), | ||
| 8771 | max<my_off_t>(max_binlog_cache_size, max_binlog_stmt_cache_size), | ||
| 8772 |
4/4✓ Branch 0 taken 2584802 times.
✓ Branch 1 taken 142 times.
✓ Branch 2 taken 43 times.
✓ Branch 3 taken 2584990 times.
|
5169835 | is_atomic_ddl)) || |
| 8773 |
3/4✓ Branch 0 taken 2584891 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 72 times.
✓ Branch 3 taken 2584819 times.
|
2584802 | DBUG_EVALUATE_IF("simulate_failure_in_before_commit_hook", true, |
| 8774 | false)) { | ||
| 8775 |
1/2✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
|
43 | trx_coordinator::rollback_in_engines(thd, all); |
| 8776 |
1/2✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
|
43 | gtid_state->update_on_rollback(thd); |
| 8777 |
2/4✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 43 times.
✗ Branch 3 not taken.
|
43 | thd_get_cache_mngr(thd)->reset(); |
| 8778 | // Reset the thread OK status before changing the outcome. | ||
| 8779 |
2/2✓ Branch 0 taken 28 times.
✓ Branch 1 taken 15 times.
|
43 | if (thd->get_stmt_da()->is_ok()) |
| 8780 |
1/2✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
|
28 | thd->get_stmt_da()->reset_diagnostics_area(); |
| 8781 |
1/2✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
|
43 | my_error(ER_RUN_HOOK_ERROR, MYF(0), "before_commit"); |
| 8782 | 43 | return RESULT_ABORTED; | |
| 8783 | } | ||
| 8784 | /* | ||
| 8785 | Check whether the transaction should commit or abort given the | ||
| 8786 | plugin feedback. | ||
| 8787 | */ | ||
| 8788 | 2584990 | if (thd->get_transaction() | |
| 8789 | ->get_rpl_transaction_ctx() | ||
| 8790 |
5/6✓ Branch 0 taken 2584997 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2584189 times.
✓ Branch 3 taken 808 times.
✓ Branch 4 taken 831 times.
✓ Branch 5 taken 2584159 times.
|
5169172 | ->is_transaction_rollback() || |
| 8791 |
3/4✓ Branch 0 taken 2584182 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
✓ Branch 3 taken 2584159 times.
|
2584189 | (DBUG_EVALUATE_IF("simulate_transaction_rollback_request", true, |
| 8792 | false))) { | ||
| 8793 |
1/2✓ Branch 0 taken 831 times.
✗ Branch 1 not taken.
|
831 | trx_coordinator::rollback_in_engines(thd, all); |
| 8794 |
1/2✓ Branch 0 taken 831 times.
✗ Branch 1 not taken.
|
831 | gtid_state->update_on_rollback(thd); |
| 8795 |
2/4✓ Branch 0 taken 831 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 831 times.
✗ Branch 3 not taken.
|
831 | thd_get_cache_mngr(thd)->reset(); |
| 8796 |
2/2✓ Branch 0 taken 802 times.
✓ Branch 1 taken 29 times.
|
831 | if (thd->get_stmt_da()->is_ok()) |
| 8797 |
1/2✓ Branch 0 taken 802 times.
✗ Branch 1 not taken.
|
802 | thd->get_stmt_da()->reset_diagnostics_area(); |
| 8798 |
1/2✓ Branch 0 taken 831 times.
✗ Branch 1 not taken.
|
831 | my_error(ER_TRANSACTION_ROLLBACK_DURING_COMMIT, MYF(0)); |
| 8799 | 831 | return RESULT_ABORTED; | |
| 8800 | } | ||
| 8801 | |||
| 8802 | #ifdef WITH_WSREP | ||
| 8803 | int error; | ||
| 8804 |
1/2✓ Branch 0 taken 2584104 times.
✗ Branch 1 not taken.
|
2584159 | const bool run_wsrep_hooks = wsrep_run_commit_hook(thd, all); |
| 8805 | /* Set this flag to trigger execution of ordered commit as part of | ||
| 8806 | thread handler flush stage append flow. */ | ||
| 8807 | 2584104 | thd->run_wsrep_ordered_commit = run_wsrep_hooks; | |
| 8808 | |||
| 8809 |
7/8✓ Branch 0 taken 46287 times.
✓ Branch 1 taken 2537817 times.
✓ Branch 2 taken 46287 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 23 times.
✓ Branch 5 taken 46264 times.
✓ Branch 6 taken 23 times.
✓ Branch 7 taken 2584081 times.
|
2584104 | if (run_wsrep_hooks && (error = wsrep_before_commit(thd, all))) { |
| 8810 |
1/2✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
|
23 | mysql_mutex_lock(&thd->LOCK_wsrep_thd); |
| 8811 |
3/6✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 23 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 23 times.
|
23 | if (run_wsrep_hooks && wsrep_must_abort(thd)) { |
| 8812 | ✗ | WSREP_DEBUG("BF abort has happened after prepare & certify"); | |
| 8813 | ✗ | mysql_mutex_unlock(&thd->LOCK_wsrep_thd); | |
| 8814 | } else { | ||
| 8815 |
1/2✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
|
23 | mysql_mutex_unlock(&thd->LOCK_wsrep_thd); |
| 8816 | } | ||
| 8817 | |||
| 8818 |
1/2✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
|
23 | ha_rollback_low(thd, all); |
| 8819 |
1/2✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
|
23 | gtid_state->update_on_rollback(thd); |
| 8820 |
2/4✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
✗ Branch 3 not taken.
|
23 | thd_get_cache_mngr(thd)->reset(); |
| 8821 | // Reset the thread OK status before changing the outcome. | ||
| 8822 |
2/6✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 23 times.
|
23 | if (!wsrep_must_replay(thd) && thd->get_stmt_da()->is_ok()) |
| 8823 | ✗ | thd->get_stmt_da()->reset_diagnostics_area(); | |
| 8824 | /* If wsrep transaction needs to replay, we didn't reset DA data. | ||
| 8825 | It will be used by replayer service. As DA::m_can_overwrite_status | ||
| 8826 | is 'true' here (set in mysql_execute_command() before | ||
| 8827 | trans_commit_stmt()) the following call to my_error() will allow | ||
| 8828 | overwriting the error */ | ||
| 8829 |
1/2✓ Branch 0 taken 23 times.
✗ Branch 1 not taken.
|
23 | my_error(ER_TRANSACTION_ROLLBACK_DURING_COMMIT, MYF(0)); |
| 8830 | 23 | return RESULT_ABORTED; | |
| 8831 | } | ||
| 8832 | |||
| 8833 |
1/2✓ Branch 0 taken 2583036 times.
✗ Branch 1 not taken.
|
2584081 | int rc = ordered_commit(thd, all, skip_commit); |
| 8834 | |||
| 8835 |
2/2✓ Branch 0 taken 46166 times.
✓ Branch 1 taken 2536870 times.
|
2583036 | if (run_wsrep_hooks) { |
| 8836 |
1/2✓ Branch 0 taken 46260 times.
✗ Branch 1 not taken.
|
46166 | wsrep_after_commit(thd, all); |
| 8837 | } | ||
| 8838 | |||
| 8839 | 2583130 | thd->run_wsrep_ordered_commit = false; | |
| 8840 | #else | ||
| 8841 | int rc = ordered_commit(thd, all, skip_commit); | ||
| 8842 | #endif /* WITH_WSREP */ | ||
| 8843 | |||
| 8844 |
2/2✓ Branch 0 taken 91 times.
✓ Branch 1 taken 2583039 times.
|
2583130 | if (rc) return RESULT_INCONSISTENT; |
| 8845 | |||
| 8846 |
4/6✓ Branch 0 taken 2582919 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 2582916 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 3 times.
|
2583039 | DBUG_EXECUTE_IF("ensure_binlog_cache_is_reset", { |
| 8847 | /* Assert that binlog cache is reset at commit time. */ | ||
| 8848 | assert(binlog_cache_is_reset); | ||
| 8849 | binlog_cache_is_reset = false; | ||
| 8850 | };); | ||
| 8851 | |||
| 8852 | /* | ||
| 8853 | Mark the flag m_is_binlogged to true only after we are done | ||
| 8854 | with checking all the error cases. | ||
| 8855 | */ | ||
| 8856 |
3/4✓ Branch 0 taken 2582750 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 530 times.
✓ Branch 3 taken 2582220 times.
|
2582919 | if (is_loggable_xa_prepare(thd)) { |
| 8857 | 530 | thd->get_transaction()->xid_state()->set_binlogged(); | |
| 8858 | /* | ||
| 8859 | Inform hook listeners that a XA PREPARE did commit, that | ||
| 8860 | is, did log a transaction to the binary log. | ||
| 8861 | */ | ||
| 8862 |
4/6✓ Branch 0 taken 530 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84 times.
✓ Branch 3 taken 446 times.
✓ Branch 4 taken 79 times.
✗ Branch 5 not taken.
|
530 | (void)RUN_HOOK(transaction, after_commit, (thd, all)); |
| 8863 | } | ||
| 8864 |
2/2✓ Branch 0 taken 5353403 times.
✓ Branch 1 taken 80 times.
|
7936228 | } else if (!skip_commit) { |
| 8865 | /* | ||
| 8866 | We only set engine binlog position in ordered_commit path flush phase | ||
| 8867 | and not all transactions go through them (such as table copy in DDL). | ||
| 8868 | So in cases where a DDL statement implicitly commits earlier transaction | ||
| 8869 | and starting a new one, the new transaction could be "leaking" the | ||
| 8870 | engine binlog pos. In order to avoid that and accidentally overwrite | ||
| 8871 | binlog position with previous location, we reset it here. | ||
| 8872 | */ | ||
| 8873 |
1/2✓ Branch 0 taken 5353708 times.
✗ Branch 1 not taken.
|
5353403 | thd->set_trans_pos(nullptr, 0); |
| 8874 |
3/4✓ Branch 0 taken 5353530 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 5353516 times.
|
5353708 | if (trx_coordinator::commit_in_engines(thd, all)) |
| 8875 | 14 | return RESULT_INCONSISTENT; | |
| 8876 | } | ||
| 8877 | |||
| 8878 | 7936341 | return RESULT_SUCCESS; | |
| 8879 | 31171067 | } | |
| 8880 | |||
| 8881 | /** | ||
| 8882 | Flush caches for session. | ||
| 8883 | |||
| 8884 | @note @c set_trans_pos is called with a pointer to the file name | ||
| 8885 | that the binary log currently use and a rotation will change the | ||
| 8886 | contents of the variable. | ||
| 8887 | |||
| 8888 | The position is used when calling the after_flush, after_commit, | ||
| 8889 | and after_rollback hooks, but these have been placed so that they | ||
| 8890 | occur before a rotation is executed. | ||
| 8891 | |||
| 8892 | It is the responsibility of any plugin that use this position to | ||
| 8893 | copy it if they need it after the hook has returned. | ||
| 8894 | |||
| 8895 | The current "global" transaction_counter is stepped and its new value | ||
| 8896 | is assigned to the transaction. | ||
| 8897 | */ | ||
| 8898 | 2585324 | std::pair<int, my_off_t> MYSQL_BIN_LOG::flush_thread_caches(THD *thd) { | |
| 8899 |
1/2✓ Branch 0 taken 2585324 times.
✗ Branch 1 not taken.
|
2585324 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd); |
| 8900 | 2585324 | my_off_t bytes = 0; | |
| 8901 | 2585324 | bool wrote_xid = false; | |
| 8902 |
1/2✓ Branch 0 taken 2585321 times.
✗ Branch 1 not taken.
|
2585324 | int error = cache_mngr->flush(thd, &bytes, &wrote_xid); |
| 8903 |
3/4✓ Branch 0 taken 2585317 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 2585317 times.
✗ Branch 3 not taken.
|
2585321 | if (!error && bytes > 0) { |
| 8904 | /* | ||
| 8905 | Note that set_trans_pos does not copy the file name. See | ||
| 8906 | this function documentation for more info. | ||
| 8907 | */ | ||
| 8908 |
1/2✓ Branch 0 taken 2585317 times.
✗ Branch 1 not taken.
|
2585317 | thd->set_trans_pos(log_file_name, m_binlog_file->position()); |
| 8909 |
3/4✓ Branch 0 taken 2039489 times.
✓ Branch 1 taken 545828 times.
✓ Branch 2 taken 2039489 times.
✗ Branch 3 not taken.
|
2585317 | if (wrote_xid) inc_prep_xids(thd); |
| 8910 | } | ||
| 8911 |
5/8✓ Branch 0 taken 2585321 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2585321 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 108 times.
✓ Branch 5 taken 2585213 times.
✓ Branch 6 taken 108 times.
✗ Branch 7 not taken.
|
2585321 | DBUG_PRINT("debug", ("bytes: %llu", bytes)); |
| 8912 |
1/2✓ Branch 0 taken 2585321 times.
✗ Branch 1 not taken.
|
5170642 | return std::make_pair(error, bytes); |
| 8913 | } | ||
| 8914 | |||
| 8915 | 2584986 | void MYSQL_BIN_LOG::init_thd_variables(THD *thd, bool all, bool skip_commit) { | |
| 8916 | /* | ||
| 8917 | These values are used while committing a transaction, so clear | ||
| 8918 | everything. | ||
| 8919 | |||
| 8920 | Notes: | ||
| 8921 | |||
| 8922 | - It would be good if we could keep transaction coordinator | ||
| 8923 | log-specific data out of the THD structure, but that is not the | ||
| 8924 | case right now. | ||
| 8925 | |||
| 8926 | - Everything in the transaction structure is reset when calling | ||
| 8927 | ha_commit_low since that calls Transaction_ctx::cleanup. | ||
| 8928 | */ | ||
| 8929 | 2584986 | thd->tx_commit_pending = true; | |
| 8930 | 2584986 | thd->commit_error = THD::CE_NONE; | |
| 8931 | 2584986 | thd->next_to_commit = nullptr; | |
| 8932 | 2584986 | thd->durability_property = HA_IGNORE_DURABILITY; | |
| 8933 | 2584986 | thd->get_transaction()->m_flags.real_commit = all; | |
| 8934 | 2585224 | thd->get_transaction()->m_flags.xid_written = false; | |
| 8935 | 2585358 | thd->get_transaction()->m_flags.commit_low = !skip_commit; | |
| 8936 | 2585352 | thd->get_transaction()->m_flags.run_hooks = !skip_commit; | |
| 8937 | #ifndef NDEBUG | ||
| 8938 | /* | ||
| 8939 | The group commit Leader may have to wait for follower whose transaction | ||
| 8940 | is not ready to be preempted. Initially the status is pessimistic. | ||
| 8941 | Preemption guarding logics is necessary only when !NDEBUG is set. | ||
| 8942 | It won't be required for the dbug-off case as long as the follower won't | ||
| 8943 | execute any thread-specific write access code in this method, which is | ||
| 8944 | the case as of current. | ||
| 8945 | */ | ||
| 8946 | 2585161 | thd->get_transaction()->m_flags.ready_preempt = false; | |
| 8947 | #endif | ||
| 8948 | 2585362 | } | |
| 8949 | |||
| 8950 | 2494628 | THD *MYSQL_BIN_LOG::fetch_and_process_flush_stage_queue( | |
| 8951 | const bool check_and_skip_flush_logs) { | ||
| 8952 | /* | ||
| 8953 | Fetch the entire flush queue and empty it, so that the next batch | ||
| 8954 | has a leader. We must do this before invoking ha_flush_logs(...) | ||
| 8955 | for guaranteeing to flush prepared records of transactions before | ||
| 8956 | flushing them to binary log, which is required by crash recovery. | ||
| 8957 | */ | ||
| 8958 | 2494628 | Commit_stage_manager::get_instance().lock_queue( | |
| 8959 | Commit_stage_manager::BINLOG_FLUSH_STAGE); | ||
| 8960 | |||
| 8961 | THD *first_seen = | ||
| 8962 | 2494628 | Commit_stage_manager::get_instance().fetch_queue_skip_acquire_lock( | |
| 8963 | Commit_stage_manager::BINLOG_FLUSH_STAGE); | ||
| 8964 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2494628 times.
|
2494628 | assert(first_seen != nullptr); |
| 8965 | |||
| 8966 | THD *commit_order_thd = | ||
| 8967 | 2494628 | Commit_stage_manager::get_instance().fetch_queue_skip_acquire_lock( | |
| 8968 | Commit_stage_manager::COMMIT_ORDER_FLUSH_STAGE); | ||
| 8969 | |||
| 8970 | 2494628 | Commit_stage_manager::get_instance().unlock_queue( | |
| 8971 | Commit_stage_manager::BINLOG_FLUSH_STAGE); | ||
| 8972 | |||
| 8973 |
3/4✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2494627 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
2494628 | if (!check_and_skip_flush_logs || |
| 8974 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | (check_and_skip_flush_logs && commit_order_thd != nullptr)) { |
| 8975 | /* | ||
| 8976 | We flush prepared records of transactions to the log of storage | ||
| 8977 | engine (for example, InnoDB redo log) in a group right before | ||
| 8978 | flushing them to binary log. | ||
| 8979 | */ | ||
| 8980 | 2494627 | ha_flush_logs(true); | |
| 8981 | } | ||
| 8982 | |||
| 8983 | /* | ||
| 8984 | The transactions are flushed to the disk and so threads | ||
| 8985 | executing slave preserve commit order can be unblocked. | ||
| 8986 | */ | ||
| 8987 | 2494624 | Commit_stage_manager::get_instance() | |
| 8988 | 2494624 | .process_final_stage_for_ordered_commit_group(commit_order_thd); | |
| 8989 | 2494624 | return first_seen; | |
| 8990 | } | ||
| 8991 | |||
| 8992 | 2494627 | int MYSQL_BIN_LOG::process_flush_stage_queue(my_off_t *total_bytes_var, | |
| 8993 | bool *rotate_var, | ||
| 8994 | THD **out_queue_var) { | ||
| 8995 |
1/2✓ Branch 0 taken 2494627 times.
✗ Branch 1 not taken.
|
2494627 | DBUG_TRACE; |
| 8996 | #ifndef NDEBUG | ||
| 8997 | // number of flushes per group. | ||
| 8998 | 2494627 | int no_flushes = 0; | |
| 8999 | #endif | ||
| 9000 |
3/6✓ Branch 0 taken 2494627 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2494627 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2494627 times.
✗ Branch 5 not taken.
|
2494627 | assert(total_bytes_var && rotate_var && out_queue_var); |
| 9001 | 2494627 | my_off_t total_bytes = 0; | |
| 9002 | 2494627 | int flush_error = 1; | |
| 9003 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 9004 | |||
| 9005 |
1/2✓ Branch 0 taken 2494623 times.
✗ Branch 1 not taken.
|
2494627 | THD *first_seen = fetch_and_process_flush_stage_queue(); |
| 9006 |
4/6✓ Branch 0 taken 2494623 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2494619 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
|
2494623 | DBUG_EXECUTE_IF("crash_after_flush_engine_log", DBUG_SUICIDE();); |
| 9007 |
2/4✓ Branch 0 taken 2494619 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2494619 times.
✗ Branch 3 not taken.
|
2494619 | CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_write_binlog"); |
| 9008 |
1/2✓ Branch 0 taken 2494619 times.
✗ Branch 1 not taken.
|
2494619 | assign_automatic_gtids_to_flush_group(first_seen); |
| 9009 | /* Flush thread caches to binary log. */ | ||
| 9010 |
2/2✓ Branch 0 taken 2585324 times.
✓ Branch 1 taken 2494616 times.
|
5079940 | for (THD *head = first_seen; head; head = head->next_to_commit) { |
| 9011 |
2/4✓ Branch 0 taken 2585324 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2585324 times.
✗ Branch 3 not taken.
|
2585324 | Thd_backup_and_restore switch_thd(current_thd, head); |
| 9012 |
1/2✓ Branch 0 taken 2585321 times.
✗ Branch 1 not taken.
|
2585324 | std::pair<int, my_off_t> result = flush_thread_caches(head); |
| 9013 | 2585321 | total_bytes += result.second; | |
| 9014 |
2/2✓ Branch 0 taken 2494616 times.
✓ Branch 1 taken 90705 times.
|
2585321 | if (flush_error == 1) flush_error = result.first; |
| 9015 | #ifndef NDEBUG | ||
| 9016 | 2585321 | no_flushes++; | |
| 9017 | #endif | ||
| 9018 | 2585321 | } | |
| 9019 | |||
| 9020 | 2494616 | *out_queue_var = first_seen; | |
| 9021 | 2494616 | *total_bytes_var = total_bytes; | |
| 9022 |
4/4✓ Branch 0 taken 2494612 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 13609 times.
✓ Branch 3 taken 2481007 times.
|
4989228 | if (total_bytes > 0 && |
| 9023 |
2/2✓ Branch 0 taken 2481004 times.
✓ Branch 1 taken 13608 times.
|
2494612 | (m_binlog_file->get_real_file_size() >= (my_off_t)max_size || |
| 9024 |
3/4✓ Branch 0 taken 2481004 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2481003 times.
|
2481004 | DBUG_EVALUATE_IF("simulate_max_binlog_size", true, false))) |
| 9025 | 13609 | *rotate_var = true; | |
| 9026 | #ifndef NDEBUG | ||
| 9027 |
5/8✓ Branch 0 taken 2494616 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2494616 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 2494505 times.
✓ Branch 6 taken 111 times.
✗ Branch 7 not taken.
|
2494616 | DBUG_PRINT("info", ("no_flushes:= %d", no_flushes)); |
| 9028 | 2494616 | no_flushes = 0; | |
| 9029 | #endif | ||
| 9030 | 2494616 | return flush_error; | |
| 9031 | 2494616 | } | |
| 9032 | |||
| 9033 | /** | ||
| 9034 | Commit a sequence of sessions. | ||
| 9035 | |||
| 9036 | This function commit an entire queue of sessions starting with the | ||
| 9037 | session in @c first. If there were an error in the flushing part of | ||
| 9038 | the ordered commit, the error code is passed in and all the threads | ||
| 9039 | are marked accordingly (but not committed). | ||
| 9040 | |||
| 9041 | It will also add the GTIDs of the transactions to gtid_executed. | ||
| 9042 | |||
| 9043 | @see MYSQL_BIN_LOG::ordered_commit | ||
| 9044 | |||
| 9045 | @param thd The "master" thread | ||
| 9046 | @param first First thread in the queue of threads to commit | ||
| 9047 | */ | ||
| 9048 | |||
| 9049 | 2471053 | void MYSQL_BIN_LOG::process_commit_stage_queue(THD *thd, THD *first) { | |
| 9050 | mysql_mutex_assert_owner(&LOCK_commit); | ||
| 9051 | #ifndef NDEBUG | ||
| 9052 | 2471053 | thd->get_transaction()->m_flags.ready_preempt = | |
| 9053 | true; // formality by the leader | ||
| 9054 | #endif | ||
| 9055 |
2/2✓ Branch 0 taken 2584577 times.
✓ Branch 1 taken 2471051 times.
|
5055628 | for (THD *head = first; head; head = head->next_to_commit) { |
| 9056 |
6/10✓ Branch 0 taken 2584577 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2584577 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 106 times.
✓ Branch 5 taken 2584471 times.
✓ Branch 6 taken 106 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 106 times.
✗ Branch 9 not taken.
|
2584577 | DBUG_PRINT("debug", ("Thread ID: %u, commit_error: %d, commit_pending: %s", |
| 9057 | head->thread_id(), head->commit_error, | ||
| 9058 | YESNO(head->tx_commit_pending))); | ||
| 9059 |
2/8✓ Branch 0 taken 2584577 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2584577 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
2584577 | DBUG_EXECUTE_IF( |
| 9060 | "block_leader_after_delete", | ||
| 9061 | if (thd != head) { DBUG_SET("+d,after_delete_wait"); };); | ||
| 9062 | /* | ||
| 9063 | If flushing failed, set commit_error for the session, skip the | ||
| 9064 | transaction and proceed with the next transaction instead. This | ||
| 9065 | will mark all threads as failed, since the flush failed. | ||
| 9066 | |||
| 9067 | If flush succeeded, attach to the session and commit it in the | ||
| 9068 | engines. | ||
| 9069 | */ | ||
| 9070 | #ifndef NDEBUG | ||
| 9071 |
2/4✓ Branch 0 taken 2584577 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2584577 times.
✗ Branch 3 not taken.
|
2584577 | Commit_stage_manager::get_instance().clear_preempt_status(head); |
| 9072 | #endif | ||
| 9073 |
2/2✓ Branch 0 taken 2584576 times.
✓ Branch 1 taken 1 times.
|
2584577 | if (head->get_transaction()->sequence_number != SEQ_UNINIT) { |
| 9074 |
1/2✓ Branch 0 taken 2584576 times.
✗ Branch 1 not taken.
|
2584576 | mysql_mutex_lock(&LOCK_replica_trans_dep_tracker); |
| 9075 |
1/2✓ Branch 0 taken 2584576 times.
✗ Branch 1 not taken.
|
2584576 | m_dependency_tracker.update_max_committed(head); |
| 9076 |
1/2✓ Branch 0 taken 2584576 times.
✗ Branch 1 not taken.
|
2584576 | mysql_mutex_unlock(&LOCK_replica_trans_dep_tracker); |
| 9077 | } | ||
| 9078 | /* | ||
| 9079 | Flush/Sync error should be ignored and continue | ||
| 9080 | to commit phase. And thd->commit_error cannot be | ||
| 9081 | COMMIT_ERROR at this moment. | ||
| 9082 | */ | ||
| 9083 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2584577 times.
|
2584577 | assert(head->commit_error != THD::CE_COMMIT_ERROR); |
| 9084 |
1/2✓ Branch 0 taken 2584577 times.
✗ Branch 1 not taken.
|
2584577 | Thd_backup_and_restore switch_thd(thd, head); |
| 9085 | 2584577 | bool all = head->get_transaction()->m_flags.real_commit; | |
| 9086 |
3/4✓ Branch 0 taken 2582758 times.
✓ Branch 1 taken 1819 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2582758 times.
|
2584577 | assert(!head->get_transaction()->m_flags.commit_low || |
| 9087 | head->get_transaction()->m_flags.ready_preempt); | ||
| 9088 |
1/2✓ Branch 0 taken 2584575 times.
✗ Branch 1 not taken.
|
2584577 | ::finish_transaction_in_engines(head, all, false); |
| 9089 |
6/10✓ Branch 0 taken 2584575 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2584575 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 106 times.
✓ Branch 5 taken 2584469 times.
✓ Branch 6 taken 106 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 106 times.
✗ Branch 9 not taken.
|
2584575 | DBUG_PRINT("debug", ("commit_error: %d, commit_pending: %s", |
| 9090 | head->commit_error, YESNO(head->tx_commit_pending))); | ||
| 9091 | 2584575 | } | |
| 9092 | |||
| 9093 |
2/2✓ Branch 0 taken 2469771 times.
✓ Branch 1 taken 1280 times.
|
2471051 | DEBUG_SYNC(thd, "process_commit_stage_queue_before_handle_gtid"); |
| 9094 | /* | ||
| 9095 | Handle the GTID of the threads. | ||
| 9096 | gtid_executed table is kept updated even though transactions fail to be | ||
| 9097 | logged. That's required by slave auto positioning. | ||
| 9098 | */ | ||
| 9099 | 2471051 | gtid_state->update_commit_group(first); | |
| 9100 | |||
| 9101 |
2/2✓ Branch 0 taken 2584563 times.
✓ Branch 1 taken 2471039 times.
|
5055602 | for (THD *head = first; head; head = head->next_to_commit) { |
| 9102 |
1/2✓ Branch 0 taken 2584563 times.
✗ Branch 1 not taken.
|
2584563 | Thd_backup_and_restore switch_thd(thd, head); |
| 9103 | 2584563 | auto all = head->get_transaction()->m_flags.real_commit; | |
| 9104 | // Mark transaction as prepared in TC, if applicable | ||
| 9105 |
1/2✓ Branch 0 taken 2584563 times.
✗ Branch 1 not taken.
|
2584563 | trx_coordinator::set_prepared_in_tc_in_engines(head, all); |
| 9106 | /* | ||
| 9107 | Decrement the prepared XID counter after storage engine commit. | ||
| 9108 | We also need decrement the prepared XID when encountering a | ||
| 9109 | flush error or session attach error for avoiding 3-way deadlock | ||
| 9110 | among user thread, rotate thread and dump thread. | ||
| 9111 | */ | ||
| 9112 |
3/4✓ Branch 0 taken 2038736 times.
✓ Branch 1 taken 545827 times.
✓ Branch 2 taken 2038736 times.
✗ Branch 3 not taken.
|
2584563 | if (head->get_transaction()->m_flags.xid_written) dec_prep_xids(head); |
| 9113 | 2584563 | } | |
| 9114 | 2471039 | } | |
| 9115 | |||
| 9116 | /** | ||
| 9117 | Process after commit for a sequence of sessions. | ||
| 9118 | |||
| 9119 | @param thd The "master" thread | ||
| 9120 | @param first First thread in the queue of threads to commit | ||
| 9121 | */ | ||
| 9122 | |||
| 9123 | 2471038 | void MYSQL_BIN_LOG::process_after_commit_stage_queue(THD *thd, THD *first) { | |
| 9124 |
2/2✓ Branch 0 taken 2584562 times.
✓ Branch 1 taken 2471031 times.
|
5055593 | for (THD *head = first; head; head = head->next_to_commit) { |
| 9125 |
4/4✓ Branch 0 taken 2582747 times.
✓ Branch 1 taken 1816 times.
✓ Branch 2 taken 2582749 times.
✓ Branch 3 taken 1814 times.
|
5167309 | if (head->get_transaction()->m_flags.run_hooks && |
| 9126 |
1/2✓ Branch 0 taken 2582748 times.
✗ Branch 1 not taken.
|
2582747 | head->commit_error != THD::CE_COMMIT_ERROR) { |
| 9127 | /* | ||
| 9128 | TODO: This hook here should probably move outside/below this | ||
| 9129 | if and be the only after_commit invocation left in the | ||
| 9130 | code. | ||
| 9131 | */ | ||
| 9132 |
1/2✓ Branch 0 taken 2582749 times.
✗ Branch 1 not taken.
|
2582749 | Thd_backup_and_restore switch_thd(thd, head); |
| 9133 | 2582749 | bool all = head->get_transaction()->m_flags.real_commit; | |
| 9134 |
4/6✓ Branch 0 taken 2582750 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 102826 times.
✓ Branch 3 taken 2479924 times.
✓ Branch 4 taken 102818 times.
✗ Branch 5 not taken.
|
2582749 | (void)RUN_HOOK(transaction, after_commit, (head, all)); |
| 9135 | /* | ||
| 9136 | When after_commit finished for the transaction, clear the run_hooks | ||
| 9137 | flag. This allow other parts of the system to check if after_commit was | ||
| 9138 | called. | ||
| 9139 | */ | ||
| 9140 | 2582742 | head->get_transaction()->m_flags.run_hooks = false; | |
| 9141 | 2582750 | } | |
| 9142 | } | ||
| 9143 | 2471031 | } | |
| 9144 | |||
| 9145 | #ifndef NDEBUG | ||
| 9146 | /** Names for the stages. */ | ||
| 9147 | static const char *g_stage_name[] = { | ||
| 9148 | "FLUSH", | ||
| 9149 | "SYNC", | ||
| 9150 | "COMMIT", | ||
| 9151 | }; | ||
| 9152 | #endif | ||
| 9153 | |||
| 9154 | 7566306 | bool MYSQL_BIN_LOG::change_stage(THD *thd [[maybe_unused]], | |
| 9155 | Commit_stage_manager::StageID stage, | ||
| 9156 | THD *queue, mysql_mutex_t *leave_mutex, | ||
| 9157 | mysql_mutex_t *enter_mutex) { | ||
| 9158 |
1/2✓ Branch 0 taken 7566631 times.
✗ Branch 1 not taken.
|
7566306 | DBUG_TRACE; |
| 9159 |
5/8✓ Branch 0 taken 7566543 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7566606 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 323 times.
✓ Branch 5 taken 7566283 times.
✓ Branch 6 taken 323 times.
✗ Branch 7 not taken.
|
7566631 | DBUG_PRINT("enter", ("thd: 0x%llx, stage: %s, queue: 0x%llx", (ulonglong)thd, |
| 9160 | g_stage_name[stage], (ulonglong)queue)); | ||
| 9161 |
2/4✓ Branch 0 taken 7566607 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7566607 times.
✗ Branch 3 not taken.
|
7566606 | assert(0 <= stage && stage < Commit_stage_manager::STAGE_COUNTER); |
| 9162 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7566607 times.
|
7566607 | assert(enter_mutex); |
| 9163 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7566607 times.
|
7566607 | assert(queue); |
| 9164 | /* | ||
| 9165 | enroll_for will release the leave_mutex once the sessions are | ||
| 9166 | queued. | ||
| 9167 | */ | ||
| 9168 |
4/6✓ Branch 0 taken 7566325 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7566211 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 113440 times.
✓ Branch 5 taken 7452771 times.
|
7566607 | if (!Commit_stage_manager::get_instance().enroll_for( |
| 9169 | stage, queue, leave_mutex, enter_mutex)) { | ||
| 9170 |
2/4✓ Branch 0 taken 113426 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 113404 times.
|
113440 | assert(!thd_get_cache_mngr(thd)->dbug_any_finalized()); |
| 9171 | 113404 | return true; | |
| 9172 | } | ||
| 9173 | |||
| 9174 | 7452771 | return false; | |
| 9175 | 7566175 | } | |
| 9176 | |||
| 9177 | /** | ||
| 9178 | Flush the I/O cache to file. | ||
| 9179 | |||
| 9180 | Flush the binary log to the binlog file if any byte where written | ||
| 9181 | and signal that the binary log file has been updated if the flush | ||
| 9182 | succeeds. | ||
| 9183 | */ | ||
| 9184 | |||
| 9185 | 2494612 | int MYSQL_BIN_LOG::flush_cache_to_file(my_off_t *end_pos_var) { | |
| 9186 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2494610 times.
|
2494612 | if (m_binlog_file->flush()) { |
| 9187 | 2 | THD *thd = current_thd; | |
| 9188 | 2 | thd->commit_error = THD::CE_FLUSH_ERROR; | |
| 9189 | 2 | return ER_ERROR_ON_WRITE; | |
| 9190 | } | ||
| 9191 | 2494610 | *end_pos_var = m_binlog_file->position(); | |
| 9192 | 2494610 | return 0; | |
| 9193 | } | ||
| 9194 | |||
| 9195 | /** | ||
| 9196 | Call fsync() to sync the file to disk. | ||
| 9197 | */ | ||
| 9198 | 4052219 | std::pair<bool, bool> MYSQL_BIN_LOG::sync_binlog_file(bool force) { | |
| 9199 | 4052219 | bool synced = false; | |
| 9200 | 4052219 | unsigned int sync_period = get_sync_period(); | |
| 9201 |
8/8✓ Branch 0 taken 4044154 times.
✓ Branch 1 taken 8065 times.
✓ Branch 2 taken 4003129 times.
✓ Branch 3 taken 41025 times.
✓ Branch 4 taken 2445182 times.
✓ Branch 5 taken 1557947 times.
✓ Branch 6 taken 2453247 times.
✓ Branch 7 taken 1598972 times.
|
4052219 | if (force || (sync_period && ++sync_counter >= sync_period)) { |
| 9202 | 2453247 | sync_counter = 0; | |
| 9203 | |||
| 9204 | /* | ||
| 9205 | There is a chance that binlog file could be closed by 'RESET MASTER' or | ||
| 9206 | or 'FLUSH LOGS' just after the leader releases LOCK_log and before it | ||
| 9207 | acquires LOCK_sync log. So it should check if m_binlog_file is opened. | ||
| 9208 | */ | ||
| 9209 |
9/12✓ Branch 0 taken 2453247 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2453243 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 2453242 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 2453242 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 2453242 times.
✓ Branch 10 taken 4 times.
✓ Branch 11 taken 2453243 times.
|
2453247 | if (DBUG_EVALUATE_IF("simulate_error_during_sync_binlog_file", 1, |
| 9210 | m_binlog_file->is_open() && m_binlog_file->sync())) { | ||
| 9211 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | THD *thd = current_thd; |
| 9212 | 4 | thd->commit_error = THD::CE_SYNC_ERROR; | |
| 9213 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | return std::make_pair(true, synced); |
| 9214 | } | ||
| 9215 | 2453243 | synced = true; | |
| 9216 | } | ||
| 9217 |
1/2✓ Branch 0 taken 4052216 times.
✗ Branch 1 not taken.
|
4052215 | return std::make_pair(false, synced); |
| 9218 | } | ||
| 9219 | |||
| 9220 | /** | ||
| 9221 | Helper function executed when leaving @c ordered_commit. | ||
| 9222 | |||
| 9223 | This function contain the necessary code for fetching the error | ||
| 9224 | code, doing post-commit checks, and wrapping up the commit if | ||
| 9225 | necessary. | ||
| 9226 | |||
| 9227 | It is typically called when enter_stage indicates that the thread | ||
| 9228 | should bail out, and also when the ultimate leader thread finishes | ||
| 9229 | executing @c ordered_commit. | ||
| 9230 | |||
| 9231 | It is typically used in this manner: | ||
| 9232 | @code | ||
| 9233 | if (enter_stage(thd, Thread_queue::BINLOG_FLUSH_STAGE, thd, &LOCK_log)) | ||
| 9234 | return finish_commit(thd); | ||
| 9235 | @endcode | ||
| 9236 | |||
| 9237 | @return Error code if the session commit failed, or zero on | ||
| 9238 | success. | ||
| 9239 | */ | ||
| 9240 | 2584665 | int MYSQL_BIN_LOG::finish_commit(THD *thd) { | |
| 9241 |
1/2✓ Branch 0 taken 2584973 times.
✗ Branch 1 not taken.
|
2584665 | DBUG_TRACE; |
| 9242 |
3/4✓ Branch 0 taken 2583608 times.
✓ Branch 1 taken 1284 times.
✓ Branch 2 taken 2583682 times.
✗ Branch 3 not taken.
|
2584973 | DEBUG_SYNC(thd, "reached_finish_commit"); |
| 9243 | /* | ||
| 9244 | In some unlikely situations, it can happen that binary | ||
| 9245 | log is closed before the thread flushes it's cache. | ||
| 9246 | In that case, clear the caches before doing commit. | ||
| 9247 | */ | ||
| 9248 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 2584746 times.
|
2584966 | if (unlikely(!is_open())) { |
| 9249 |
1/2✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
|
15 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd); |
| 9250 |
2/4✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
|
15 | if (cache_mngr) cache_mngr->reset(); |
| 9251 | } | ||
| 9252 | |||
| 9253 |
2/2✓ Branch 0 taken 624 times.
✓ Branch 1 taken 2583967 times.
|
2584761 | if (thd->get_transaction()->sequence_number != SEQ_UNINIT) { |
| 9254 |
1/2✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
|
624 | mysql_mutex_lock(&LOCK_replica_trans_dep_tracker); |
| 9255 |
1/2✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
|
624 | m_dependency_tracker.update_max_committed(thd); |
| 9256 |
1/2✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
|
624 | mysql_mutex_unlock(&LOCK_replica_trans_dep_tracker); |
| 9257 | } | ||
| 9258 | |||
| 9259 | 2584591 | auto all = thd->get_transaction()->m_flags.real_commit; | |
| 9260 | 2584545 | auto committed_low = thd->get_transaction()->m_flags.commit_low; | |
| 9261 | |||
| 9262 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2584696 times.
|
2584696 | assert(thd->commit_error != THD::CE_COMMIT_ERROR); |
| 9263 |
1/2✓ Branch 0 taken 2584665 times.
✗ Branch 1 not taken.
|
2584696 | ::finish_transaction_in_engines(thd, all, false); |
| 9264 | |||
| 9265 | // If the ordered commit didn't updated the GTIDs for this thd yet | ||
| 9266 | // at process_commit_stage_queue (i.e. --binlog-order-commits=0) | ||
| 9267 | // the thd still has the ownership of a GTID and we must handle it. | ||
| 9268 |
3/4✓ Branch 0 taken 2584230 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1316 times.
✓ Branch 3 taken 2582914 times.
|
2584665 | if (!thd->owned_gtid_is_empty()) { |
| 9269 |
1/2✓ Branch 0 taken 1316 times.
✗ Branch 1 not taken.
|
1316 | if (thd->commit_error == THD::CE_NONE) { |
| 9270 |
1/2✓ Branch 0 taken 1316 times.
✗ Branch 1 not taken.
|
1316 | gtid_state->update_on_commit(thd); |
| 9271 | } else | ||
| 9272 | ✗ | gtid_state->update_on_rollback(thd); | |
| 9273 | } | ||
| 9274 | |||
| 9275 | // If not yet done, mark transaction as prepared in TC, if applicable and | ||
| 9276 | // unfence the rotation of the binary log | ||
| 9277 |
2/2✓ Branch 0 taken 624 times.
✓ Branch 1 taken 2583588 times.
|
2584230 | if (thd->get_transaction()->m_flags.xid_written) { |
| 9278 |
1/2✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
|
624 | trx_coordinator::set_prepared_in_tc_in_engines(thd, all); |
| 9279 |
1/2✓ Branch 0 taken 568 times.
✗ Branch 1 not taken.
|
624 | dec_prep_xids(thd); |
| 9280 | } | ||
| 9281 | |||
| 9282 | // If the transaction was committed successfully, run the after_commit | ||
| 9283 |
5/6✓ Branch 0 taken 1026 times.
✓ Branch 1 taken 2583130 times.
✓ Branch 2 taken 1026 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 624 times.
✓ Branch 5 taken 2583532 times.
|
2585182 | if (committed_low && (thd->commit_error != THD::CE_COMMIT_ERROR) && |
| 9284 |
2/2✓ Branch 0 taken 624 times.
✓ Branch 1 taken 402 times.
|
1026 | thd->get_transaction()->m_flags.run_hooks) { |
| 9285 |
4/6✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✓ Branch 3 taken 606 times.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
|
624 | (void)RUN_HOOK(transaction, after_commit, (thd, all)); |
| 9286 | 624 | thd->get_transaction()->m_flags.run_hooks = false; | |
| 9287 | } | ||
| 9288 | |||
| 9289 |
2/10✓ Branch 0 taken 2584045 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2584045 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
2584156 | DBUG_EXECUTE_IF("leaving_finish_commit", { |
| 9290 | const char act[] = "now SIGNAL signal_leaving_finish_commit"; | ||
| 9291 | assert(!debug_sync_set_action(current_thd, STRING_WITH_LEN(act))); | ||
| 9292 | };); | ||
| 9293 | |||
| 9294 |
3/4✓ Branch 0 taken 2574119 times.
✓ Branch 1 taken 9926 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2574068 times.
|
2584045 | assert(thd->commit_error || !thd->get_transaction()->m_flags.run_hooks); |
| 9295 |
2/4✓ Branch 0 taken 2584390 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2584258 times.
|
2583994 | assert(!thd_get_cache_mngr(thd)->dbug_any_finalized()); |
| 9296 |
5/8✓ Branch 0 taken 2583926 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2583849 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 106 times.
✓ Branch 5 taken 2583743 times.
✓ Branch 6 taken 106 times.
✗ Branch 7 not taken.
|
2584258 | DBUG_PRINT("return", ("Thread ID: %u, commit_error: %d", thd->thread_id(), |
| 9297 | thd->commit_error)); | ||
| 9298 | /* | ||
| 9299 | flush or sync errors are handled by the leader of the group | ||
| 9300 | (using binlog_error_action). Hence treat only COMMIT_ERRORs as errors. | ||
| 9301 | */ | ||
| 9302 | 2584779 | return thd->commit_error == THD::CE_COMMIT_ERROR; | |
| 9303 | 2583849 | } | |
| 9304 | |||
| 9305 | /** | ||
| 9306 | Auxiliary function used in ordered_commit. | ||
| 9307 | */ | ||
| 9308 | 2471667 | static inline int call_after_sync_hook(THD *queue_head) { | |
| 9309 | 2471667 | const char *log_file = nullptr; | |
| 9310 | 2471667 | my_off_t pos = 0; | |
| 9311 | |||
| 9312 |
3/4✓ Branch 0 taken 2471667 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2447192 times.
✓ Branch 3 taken 24475 times.
|
2471667 | if (NO_HOOK(binlog_storage)) return 0; |
| 9313 | |||
| 9314 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24475 times.
|
24475 | assert(queue_head != nullptr); |
| 9315 |
2/2✓ Branch 0 taken 63550 times.
✓ Branch 1 taken 24475 times.
|
88025 | for (THD *thd = queue_head; thd != nullptr; thd = thd->next_to_commit) |
| 9316 |
1/2✓ Branch 0 taken 63550 times.
✗ Branch 1 not taken.
|
63550 | if (likely(thd->commit_error == THD::CE_NONE)) |
| 9317 |
1/2✓ Branch 0 taken 63550 times.
✗ Branch 1 not taken.
|
63550 | thd->get_trans_fixed_pos(&log_file, &pos); |
| 9318 | |||
| 9319 |
6/8✓ Branch 0 taken 24475 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24472 times.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 24472 times.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 24472 times.
|
48947 | if (DBUG_EVALUATE_IF("simulate_after_sync_hook_error", 1, 0) || |
| 9320 |
3/6✓ Branch 0 taken 24472 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24472 times.
✓ Branch 4 taken 24472 times.
✗ Branch 5 not taken.
|
24472 | RUN_HOOK(binlog_storage, after_sync, (queue_head, log_file, pos))) { |
| 9321 |
8/16✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 3 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 3 times.
✗ Branch 15 not taken.
|
3 | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_RUN_AFTER_SYNC_HOOK); |
| 9322 | 3 | return ER_ERROR_ON_WRITE; | |
| 9323 | } | ||
| 9324 | 24472 | return 0; | |
| 9325 | } | ||
| 9326 | |||
| 9327 | /** | ||
| 9328 | Helper function to handle flush or sync stage errors. | ||
| 9329 | If binlog_error_action= ABORT_SERVER, server will be aborted | ||
| 9330 | after reporting the error to the client. | ||
| 9331 | If binlog_error_action= IGNORE_ERROR, binlog will be closed | ||
| 9332 | for the reset of the life time of the server. close() call is protected | ||
| 9333 | with LOCK_log to avoid any parallel operations on binary log. | ||
| 9334 | |||
| 9335 | @param thd Thread object that faced flush/sync error | ||
| 9336 | @param need_lock_log | ||
| 9337 | > Indicates true if LOCk_log is needed before closing | ||
| 9338 | binlog (happens when we are handling sync error) | ||
| 9339 | > Indicates false if LOCK_log is already acquired | ||
| 9340 | by the thread (happens when we are handling flush | ||
| 9341 | error) | ||
| 9342 | @param message Message stating the reason of the failure | ||
| 9343 | */ | ||
| 9344 | 14 | void MYSQL_BIN_LOG::handle_binlog_flush_or_sync_error(THD *thd, | |
| 9345 | bool need_lock_log, | ||
| 9346 | const char *message) { | ||
| 9347 | 14 | char errmsg[MYSQL_ERRMSG_SIZE] = {0}; | |
| 9348 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 2 times.
|
14 | if (message == nullptr) |
| 9349 | 24 | sprintf( | |
| 9350 | errmsg, | ||
| 9351 | "An error occurred during %s stage of the commit. " | ||
| 9352 | "'binlog_error_action' is set to '%s'.", | ||
| 9353 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 7 times.
|
12 | thd->commit_error == THD::CE_FLUSH_ERROR ? "flush" : "sync", |
| 9354 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | binlog_error_action == ABORT_SERVER ? "ABORT_SERVER" : "IGNORE_ERROR"); |
| 9355 | else | ||
| 9356 | 2 | strncpy(errmsg, message, MYSQL_ERRMSG_SIZE - 1); | |
| 9357 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
|
14 | if (binlog_error_action == ABORT_SERVER) { |
| 9358 | char err_buff[MYSQL_ERRMSG_SIZE + 25]; | ||
| 9359 | ✗ | sprintf(err_buff, "%s Server is being stopped.", errmsg); | |
| 9360 | ✗ | exec_binlog_error_action_abort(err_buff); | |
| 9361 | } else { | ||
| 9362 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | DEBUG_SYNC(thd, "before_binlog_closed_due_to_error"); |
| 9363 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 6 times.
|
14 | if (need_lock_log) |
| 9364 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
8 | mysql_mutex_lock(&LOCK_log); |
| 9365 | else | ||
| 9366 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 9367 | /* | ||
| 9368 | It can happen that other group leader encountered | ||
| 9369 | error and already closed the binary log. So print | ||
| 9370 | error only if it is in open state. But we should | ||
| 9371 | call close() always just in case if the previous | ||
| 9372 | close did not close index file. | ||
| 9373 | */ | ||
| 9374 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 1 times.
|
14 | if (is_open()) { |
| 9375 |
8/16✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 13 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 13 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 13 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 13 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 13 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 13 times.
✗ Branch 15 not taken.
|
13 | LogErr(ERROR_LEVEL, ER_TURNING_LOGGING_OFF_FOR_THE_DURATION, errmsg); |
| 9376 | } | ||
| 9377 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
14 | close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT, false /*need_lock_log=false*/, |
| 9378 | true /*need_lock_index=true*/); | ||
| 9379 | /* | ||
| 9380 | If there is a write error (flush/sync stage) and if | ||
| 9381 | binlog_error_action=IGNORE_ERROR, clear the error | ||
| 9382 | and allow the commit to happen in storage engine. | ||
| 9383 | */ | ||
| 9384 |
5/6✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 12 times.
|
17 | if (check_write_error(thd) && |
| 9385 |
3/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
|
3 | DBUG_EVALUATE_IF("simulate_cache_creation_failure", false, true)) { |
| 9386 | /* we have DA_ERROR */ | ||
| 9387 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | thd->clear_error(); /* sets thd->get_stmt_da()->status() to DA_EMPTY */ |
| 9388 | /* For SQLCOM_COMMIT, ROLLBACK, ROLLBACK TO SAVEPOINT, there is already | ||
| 9389 | my_ok() in mysql_execute_command. Doing double my_ok() is not allowed. So | ||
| 9390 | we avoid that here */ | ||
| 9391 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | if (thd_sql_command(thd) != SQLCOM_COMMIT && |
| 9392 |
6/8✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 1 times.
|
3 | thd_sql_command(thd) != SQLCOM_ROLLBACK && |
| 9393 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | thd_sql_command(thd) != SQLCOM_ROLLBACK_TO_SAVEPOINT) { |
| 9394 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_ok(thd); /* sets thd->get_stmt_da()->status() to DA_OK */ |
| 9395 | } | ||
| 9396 | } | ||
| 9397 | |||
| 9398 |
3/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
|
14 | if (need_lock_log) mysql_mutex_unlock(&LOCK_log); |
| 9399 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | DEBUG_SYNC(thd, "after_binlog_closed_due_to_error"); |
| 9400 | } | ||
| 9401 | 14 | } | |
| 9402 | |||
| 9403 | 2585087 | int MYSQL_BIN_LOG::ordered_commit(THD *thd, bool all, bool skip_commit) { | |
| 9404 |
1/2✓ Branch 0 taken 2585427 times.
✗ Branch 1 not taken.
|
2585087 | DBUG_TRACE; |
| 9405 | 2585427 | int flush_error = 0, sync_error = 0; | |
| 9406 | 2585427 | my_off_t total_bytes = 0; | |
| 9407 | 2585427 | bool do_rotate = false; | |
| 9408 | |||
| 9409 |
4/6✓ Branch 0 taken 2585271 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.
✓ Branch 3 taken 2585181 times.
✓ Branch 4 taken 90 times.
✗ Branch 5 not taken.
|
2585427 | DBUG_EXECUTE_IF("crash_commit_before_log", DBUG_SUICIDE();); |
| 9410 | |||
| 9411 | #ifdef WITH_WSREP | ||
| 9412 |
9/10✓ Branch 0 taken 2585211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 59175 times.
✓ Branch 3 taken 2526036 times.
✓ Branch 4 taken 59165 times.
✓ Branch 5 taken 10 times.
✓ Branch 6 taken 59109 times.
✓ Branch 7 taken 56 times.
✓ Branch 8 taken 26 times.
✓ Branch 9 taken 59083 times.
|
2585181 | if (WSREP_EMULATE_BINLOG(thd)) { |
| 9413 | /* | ||
| 9414 | Skip group commit, just do storage engine commit. | ||
| 9415 | */ | ||
| 9416 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | int rcode = ha_commit_low(thd, all); |
| 9417 | |||
| 9418 | /* if there is myisam statement inside innodb transaction, we may | ||
| 9419 | have events in stmt cache | ||
| 9420 | */ | ||
| 9421 |
1/2✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
|
26 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); |
| 9422 |
3/4✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 24 times.
|
26 | if (!cache_mngr->stmt_cache.is_binlog_empty()) { |
| 9423 |
1/40✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
✗ Branch 31 not taken.
✗ Branch 32 not taken.
✗ Branch 33 not taken.
✗ Branch 34 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✗ Branch 37 not taken.
✗ Branch 38 not taken.
✗ Branch 39 not taken.
|
2 | WSREP_DEBUG("stmt transaction inside MST, SQL: %s", WSREP_QUERY(thd)); |
| 9424 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | cache_mngr->stmt_cache.reset(); |
| 9425 | } | ||
| 9426 | 26 | return rcode; | |
| 9427 | } | ||
| 9428 | #endif /* WITH_WSREP */ | ||
| 9429 | |||
| 9430 |
1/2✓ Branch 0 taken 2584962 times.
✗ Branch 1 not taken.
|
2585155 | init_thd_variables(thd, all, skip_commit); |
| 9431 |
6/10✓ Branch 0 taken 2585097 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2585223 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 111 times.
✓ Branch 5 taken 2585112 times.
✓ Branch 6 taken 111 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 111 times.
✗ Branch 9 not taken.
|
2584962 | DBUG_PRINT("enter", ("commit_pending: %s, commit_error: %d, thread_id: %u", |
| 9432 | YESNO(thd->tx_commit_pending), thd->commit_error, | ||
| 9433 | thd->thread_id())); | ||
| 9434 | |||
| 9435 |
3/4✓ Branch 0 taken 2583856 times.
✓ Branch 1 taken 1279 times.
✓ Branch 2 taken 2584051 times.
✗ Branch 3 not taken.
|
2585223 | DEBUG_SYNC(thd, "bgc_before_flush_stage"); |
| 9436 | |||
| 9437 | /* | ||
| 9438 | Stage #0: ensure slave threads commit order as they appear in the slave's | ||
| 9439 | relay log for transactions flushing to binary log. | ||
| 9440 | |||
| 9441 | This will make thread wait until its turn to commit. | ||
| 9442 | Commit_order_manager maintains it own queue and its own order for the | ||
| 9443 | commit. So Stage#0 doesn't maintain separate StageID. | ||
| 9444 | */ | ||
| 9445 |
1/2✓ Branch 0 taken 2585096 times.
✗ Branch 1 not taken.
|
2585330 | if (Commit_order_manager::wait_for_its_turn_before_flush_stage(thd) || |
| 9446 |
7/8✓ Branch 0 taken 2570976 times.
✓ Branch 1 taken 14120 times.
✓ Branch 2 taken 2571042 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 187682 times.
✓ Branch 5 taken 2383360 times.
✓ Branch 6 taken 2397551 times.
✓ Branch 7 taken 187679 times.
|
2772846 | ending_trans(thd, all) || |
| 9447 |
2/4✓ Branch 0 taken 187750 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 187756 times.
|
187682 | Commit_order_manager::get_rollback_status(thd)) { |
| 9448 |
3/4✓ Branch 0 taken 2397554 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 83 times.
✓ Branch 3 taken 2397471 times.
|
2397551 | if (Commit_order_manager::wait(thd)) { |
| 9449 | 83 | return thd->commit_error; | |
| 9450 | } | ||
| 9451 | } | ||
| 9452 | |||
| 9453 | /* | ||
| 9454 | Stage #1: flushing transactions to binary log | ||
| 9455 | |||
| 9456 | While flushing, we allow new threads to enter and will process | ||
| 9457 | them in due time. Once the queue was empty, we cannot reap | ||
| 9458 | anything more since it is possible that a thread entered and | ||
| 9459 | appointed itself leader for the flush phase. | ||
| 9460 | */ | ||
| 9461 | |||
| 9462 |
3/4✓ Branch 0 taken 2585015 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 90440 times.
✓ Branch 3 taken 2494575 times.
|
2585150 | if (change_stage(thd, Commit_stage_manager::BINLOG_FLUSH_STAGE, thd, nullptr, |
| 9463 | &LOCK_log)) { | ||
| 9464 |
3/8✓ Branch 0 taken 90402 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 90422 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 90422 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
90440 | DBUG_PRINT("return", ("Thread ID: %u, commit_error: %d", thd->thread_id(), |
| 9465 | thd->commit_error)); | ||
| 9466 |
1/2✓ Branch 0 taken 90420 times.
✗ Branch 1 not taken.
|
90422 | return finish_commit(thd); |
| 9467 | } | ||
| 9468 | |||
| 9469 | #ifdef WITH_WSREP | ||
| 9470 |
3/4✓ Branch 0 taken 2493348 times.
✓ Branch 1 taken 1280 times.
✓ Branch 2 taken 2493348 times.
✗ Branch 3 not taken.
|
2494575 | DEBUG_SYNC(thd, "pxc_in_commit_flush_stage"); |
| 9471 | #endif /* WITH_WSREP */ | ||
| 9472 | |||
| 9473 | 2494628 | THD *wait_queue = nullptr, *final_queue = nullptr; | |
| 9474 | 2494628 | mysql_mutex_t *leave_mutex_before_commit_stage = nullptr; | |
| 9475 | 2494628 | my_off_t flush_end_pos = 0; | |
| 9476 | bool update_binlog_end_pos_after_sync; | ||
| 9477 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2494627 times.
|
2494628 | if (unlikely(!is_open())) { |
| 9478 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | final_queue = fetch_and_process_flush_stage_queue(true); |
| 9479 | 1 | leave_mutex_before_commit_stage = &LOCK_log; | |
| 9480 | /* | ||
| 9481 | binary log is closed, flush stage and sync stage should be | ||
| 9482 | ignored. Binlog cache should be cleared, but instead of doing | ||
| 9483 | it here, do that work in 'finish_commit' function so that | ||
| 9484 | leader and followers thread caches will be cleared. | ||
| 9485 | */ | ||
| 9486 | 1 | goto commit_stage; | |
| 9487 | } | ||
| 9488 |
3/4✓ Branch 0 taken 2493347 times.
✓ Branch 1 taken 1280 times.
✓ Branch 2 taken 2493347 times.
✗ Branch 3 not taken.
|
2494627 | DEBUG_SYNC(thd, "waiting_in_the_middle_of_flush_stage"); |
| 9489 | flush_error = | ||
| 9490 |
1/2✓ Branch 0 taken 2494616 times.
✗ Branch 1 not taken.
|
2494627 | process_flush_stage_queue(&total_bytes, &do_rotate, &wait_queue); |
| 9491 | |||
| 9492 |
3/4✓ Branch 0 taken 2494612 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 2494612 times.
✗ Branch 3 not taken.
|
2494616 | if (flush_error == 0 && total_bytes > 0) |
| 9493 |
1/2✓ Branch 0 taken 2494612 times.
✗ Branch 1 not taken.
|
2494612 | flush_error = flush_cache_to_file(&flush_end_pos); |
| 9494 |
4/6✓ Branch 0 taken 2494616 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2494612 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
|
2494616 | DBUG_EXECUTE_IF("crash_after_flush_binlog", DBUG_SUICIDE();); |
| 9495 | |||
| 9496 | 2494612 | update_binlog_end_pos_after_sync = (get_sync_period() == 1); | |
| 9497 | |||
| 9498 | /* | ||
| 9499 | If the flush finished successfully, we can call the after_flush | ||
| 9500 | hook. Being invoked here, we have the guarantee that the hook is | ||
| 9501 | executed before the before/after_send_hooks on the dump thread | ||
| 9502 | preventing race conditions among these plug-ins. | ||
| 9503 | */ | ||
| 9504 |
2/2✓ Branch 0 taken 2494606 times.
✓ Branch 1 taken 6 times.
|
2494612 | if (flush_error == 0) { |
| 9505 |
1/2✓ Branch 0 taken 2494606 times.
✗ Branch 1 not taken.
|
2494606 | const char *file_name_ptr = log_file_name + dirname_length(log_file_name); |
| 9506 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2494606 times.
|
2494606 | assert(flush_end_pos != 0); |
| 9507 |
5/8✓ Branch 0 taken 2494606 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2463460 times.
✓ Branch 3 taken 31146 times.
✓ Branch 4 taken 31146 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2494606 times.
|
2494606 | if (RUN_HOOK(binlog_storage, after_flush, |
| 9508 | (thd, file_name_ptr, flush_end_pos))) { | ||
| 9509 | ✗ | LogErr(ERROR_LEVEL, ER_BINLOG_FAILED_TO_RUN_AFTER_FLUSH_HOOK); | |
| 9510 | ✗ | flush_error = ER_ERROR_ON_WRITE; | |
| 9511 | } | ||
| 9512 | |||
| 9513 |
3/4✓ Branch 0 taken 42688 times.
✓ Branch 1 taken 2451918 times.
✓ Branch 2 taken 42688 times.
✗ Branch 3 not taken.
|
2494606 | if (!update_binlog_end_pos_after_sync) update_binlog_end_pos(); |
| 9514 | |||
| 9515 |
4/6✓ Branch 0 taken 2494606 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 117 times.
✓ Branch 3 taken 2494489 times.
✓ Branch 4 taken 117 times.
✗ Branch 5 not taken.
|
2494606 | DBUG_EXECUTE_IF("crash_commit_after_log", DBUG_SUICIDE();); |
| 9516 | } | ||
| 9517 | |||
| 9518 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2494489 times.
|
2494495 | if (flush_error) { |
| 9519 | /* | ||
| 9520 | Handle flush error (if any) after leader finishes it's flush stage. | ||
| 9521 | */ | ||
| 9522 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | handle_binlog_flush_or_sync_error( |
| 9523 | thd, false /* need_lock_log */, | ||
| 9524 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
|
6 | (thd->commit_error == THD::CE_FLUSH_GNO_EXHAUSTED_ERROR) |
| 9525 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | ? ER_THD(thd, ER_GNO_EXHAUSTED) |
| 9526 | : nullptr); | ||
| 9527 | } | ||
| 9528 | |||
| 9529 |
1/2✓ Branch 0 taken 2494495 times.
✗ Branch 1 not taken.
|
2494495 | publish_coordinates_for_global_status(); |
| 9530 | |||
| 9531 |
3/4✓ Branch 0 taken 2493215 times.
✓ Branch 1 taken 1280 times.
✓ Branch 2 taken 2493215 times.
✗ Branch 3 not taken.
|
2494495 | DEBUG_SYNC(thd, "bgc_after_flush_stage_before_sync_stage"); |
| 9532 | |||
| 9533 | /* | ||
| 9534 | Stage #2: Syncing binary log file to disk | ||
| 9535 | */ | ||
| 9536 | |||
| 9537 |
3/4✓ Branch 0 taken 2494478 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6942 times.
✓ Branch 3 taken 2487536 times.
|
2494495 | if (change_stage(thd, Commit_stage_manager::SYNC_STAGE, wait_queue, &LOCK_log, |
| 9538 | &LOCK_sync)) { | ||
| 9539 |
3/8✓ Branch 0 taken 6937 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6939 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6939 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
6942 | DBUG_PRINT("return", ("Thread ID: %u, commit_error: %d", thd->thread_id(), |
| 9540 | thd->commit_error)); | ||
| 9541 |
1/2✓ Branch 0 taken 6936 times.
✗ Branch 1 not taken.
|
6939 | return finish_commit(thd); |
| 9542 | } | ||
| 9543 | |||
| 9544 | /* | ||
| 9545 | Shall introduce a delay only if it is going to do sync | ||
| 9546 | in this ongoing SYNC stage. The "+1" used below in the | ||
| 9547 | if condition is to count the ongoing sync stage. | ||
| 9548 | When sync_binlog=0 (where we never do sync in BGC group), | ||
| 9549 | it is considered as a special case and delay will be executed | ||
| 9550 | for every group just like how it is done when sync_binlog= 1. | ||
| 9551 | */ | ||
| 9552 |
5/6✓ Branch 0 taken 2487536 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2486110 times.
✓ Branch 3 taken 1426 times.
✓ Branch 4 taken 2486110 times.
✓ Branch 5 taken 1426 times.
|
2487536 | if (!flush_error && (sync_counter + 1 >= get_sync_period())) |
| 9553 |
2/4✓ Branch 0 taken 2486110 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2486110 times.
✗ Branch 3 not taken.
|
2486110 | Commit_stage_manager::get_instance().wait_count_or_timeout( |
| 9554 | opt_binlog_group_commit_sync_no_delay_count, | ||
| 9555 | opt_binlog_group_commit_sync_delay, Commit_stage_manager::SYNC_STAGE); | ||
| 9556 | |||
| 9557 |
2/4✓ Branch 0 taken 2487542 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2487542 times.
✗ Branch 3 not taken.
|
2487536 | final_queue = Commit_stage_manager::get_instance().fetch_queue_acquire_lock( |
| 9558 | Commit_stage_manager::SYNC_STAGE); | ||
| 9559 | |||
| 9560 |
3/4✓ Branch 0 taken 2487536 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 2487536 times.
✗ Branch 3 not taken.
|
2487542 | if (flush_error == 0 && total_bytes > 0) { |
| 9561 |
3/4✓ Branch 0 taken 2486256 times.
✓ Branch 1 taken 1280 times.
✓ Branch 2 taken 2486256 times.
✗ Branch 3 not taken.
|
2487536 | DEBUG_SYNC(thd, "before_sync_binlog_file"); |
| 9562 |
1/2✓ Branch 0 taken 2487536 times.
✗ Branch 1 not taken.
|
2487536 | std::pair<bool, bool> result = sync_binlog_file(false); |
| 9563 | 2487536 | sync_error = result.first; | |
| 9564 | } | ||
| 9565 | |||
| 9566 |
2/2✓ Branch 0 taken 2445090 times.
✓ Branch 1 taken 42452 times.
|
2487542 | if (update_binlog_end_pos_after_sync) { |
| 9567 | 2445090 | THD *tmp_thd = final_queue; | |
| 9568 | 2445090 | const char *binlog_file = nullptr; | |
| 9569 | 2445090 | my_off_t pos = 0; | |
| 9570 |
2/2✓ Branch 0 taken 48502 times.
✓ Branch 1 taken 2445090 times.
|
2493592 | while (tmp_thd->next_to_commit != nullptr) |
| 9571 | 48502 | tmp_thd = tmp_thd->next_to_commit; | |
| 9572 |
4/4✓ Branch 0 taken 2445084 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 2445080 times.
✓ Branch 3 taken 4 times.
|
2445090 | if (flush_error == 0 && sync_error == 0) { |
| 9573 |
1/2✓ Branch 0 taken 2445080 times.
✗ Branch 1 not taken.
|
2445080 | tmp_thd->get_trans_fixed_pos(&binlog_file, &pos); |
| 9574 |
1/2✓ Branch 0 taken 2445080 times.
✗ Branch 1 not taken.
|
2445080 | update_binlog_end_pos(binlog_file, pos); |
| 9575 | } | ||
| 9576 | } | ||
| 9577 | |||
| 9578 |
3/4✓ Branch 0 taken 2486262 times.
✓ Branch 1 taken 1280 times.
✓ Branch 2 taken 2486262 times.
✗ Branch 3 not taken.
|
2487542 | DEBUG_SYNC(thd, "bgc_after_sync_stage_before_commit_stage"); |
| 9579 | |||
| 9580 | 2487542 | leave_mutex_before_commit_stage = &LOCK_sync; | |
| 9581 | /* | ||
| 9582 | Stage #3: Commit all transactions in order. | ||
| 9583 | |||
| 9584 | This stage is skipped if we do not need to order the commits and | ||
| 9585 | each thread have to execute the handlerton commit instead. | ||
| 9586 | |||
| 9587 | However, since we are keeping the lock from the previous stage, we | ||
| 9588 | need to unlock it if we skip the stage. | ||
| 9589 | |||
| 9590 | We must also step commit_clock before the ha_commit_low() is called | ||
| 9591 | either in ordered fashion (by the leader of this stage) or by the thread | ||
| 9592 | themselves. | ||
| 9593 | |||
| 9594 | We are delaying the handling of sync error until | ||
| 9595 | all locks are released but we should not enter into | ||
| 9596 | commit stage if binlog_error_action is ABORT_SERVER. | ||
| 9597 | */ | ||
| 9598 | 2487543 | commit_stage: | |
| 9599 | /* Clone needs binlog commit order. */ | ||
| 9600 |
7/8✓ Branch 0 taken 624 times.
✓ Branch 1 taken 2486919 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 624 times.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 2486915 times.
✓ Branch 6 taken 2486919 times.
✓ Branch 7 taken 624 times.
|
2487547 | if ((opt_binlog_order_commits || Clone_handler::need_commit_order()) && |
| 9601 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | (sync_error == 0 || binlog_error_action != ABORT_SERVER)) { |
| 9602 |
3/4✓ Branch 0 taken 2486899 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15849 times.
✓ Branch 3 taken 2471050 times.
|
2486919 | if (change_stage(thd, Commit_stage_manager::COMMIT_STAGE, final_queue, |
| 9603 | leave_mutex_before_commit_stage, &LOCK_commit)) { | ||
| 9604 |
3/8✓ Branch 0 taken 15836 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15831 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15831 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
15849 | DBUG_PRINT("return", ("Thread ID: %u, commit_error: %d", thd->thread_id(), |
| 9605 | thd->commit_error)); | ||
| 9606 |
1/2✓ Branch 0 taken 15837 times.
✗ Branch 1 not taken.
|
15831 | return finish_commit(thd); |
| 9607 | } | ||
| 9608 | THD *commit_queue = | ||
| 9609 |
2/4✓ Branch 0 taken 2471053 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2471053 times.
✗ Branch 3 not taken.
|
2471050 | Commit_stage_manager::get_instance().fetch_queue_acquire_lock( |
| 9610 | Commit_stage_manager::COMMIT_STAGE); | ||
| 9611 |
5/8✓ Branch 0 taken 2471053 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 186 times.
✓ Branch 3 taken 2470867 times.
✓ Branch 4 taken 186 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 186 times.
✗ Branch 7 not taken.
|
2471053 | DBUG_EXECUTE_IF("semi_sync_3-way_deadlock", |
| 9612 | DEBUG_SYNC(thd, "before_process_commit_stage_queue");); | ||
| 9613 | |||
| 9614 |
4/4✓ Branch 0 taken 2471047 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 2471043 times.
✓ Branch 3 taken 4 times.
|
2471053 | if (flush_error == 0 && sync_error == 0) |
| 9615 |
1/2✓ Branch 0 taken 2471043 times.
✗ Branch 1 not taken.
|
2471043 | sync_error = call_after_sync_hook(commit_queue); |
| 9616 | |||
| 9617 | /* | ||
| 9618 | process_commit_stage_queue will call update_on_commit or | ||
| 9619 | update_on_rollback for the GTID owned by each thd in the queue. | ||
| 9620 | |||
| 9621 | This will be done this way to guarantee that GTIDs are added to | ||
| 9622 | gtid_executed in order, to avoid creating unnecessary temporary | ||
| 9623 | gaps and keep gtid_executed as a single interval at all times. | ||
| 9624 | |||
| 9625 | If we allow each thread to call update_on_commit only when they | ||
| 9626 | are at finish_commit, the GTID order cannot be guaranteed and | ||
| 9627 | temporary gaps may appear in gtid_executed. When this happen, | ||
| 9628 | the server would have to add and remove intervals from the | ||
| 9629 | Gtid_set, and adding and removing intervals requires a mutex, | ||
| 9630 | which would reduce performance. | ||
| 9631 | */ | ||
| 9632 |
1/2✓ Branch 0 taken 2471039 times.
✗ Branch 1 not taken.
|
2471053 | process_commit_stage_queue(thd, commit_queue); |
| 9633 |
1/2✓ Branch 0 taken 2471039 times.
✗ Branch 1 not taken.
|
2471039 | mysql_mutex_unlock(&LOCK_commit); |
| 9634 | /* | ||
| 9635 | Process after_commit after LOCK_commit is released for avoiding | ||
| 9636 | 3-way deadlock among user thread, rotate thread and dump thread. | ||
| 9637 | */ | ||
| 9638 |
1/2✓ Branch 0 taken 2471029 times.
✗ Branch 1 not taken.
|
2471039 | process_after_commit_stage_queue(thd, commit_queue); |
| 9639 | 2471029 | final_queue = commit_queue; | |
| 9640 | } else { | ||
| 9641 |
1/2✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
|
624 | if (leave_mutex_before_commit_stage) |
| 9642 |
1/2✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
|
624 | mysql_mutex_unlock(leave_mutex_before_commit_stage); |
| 9643 |
2/4✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 624 times.
✗ Branch 3 not taken.
|
624 | if (flush_error == 0 && sync_error == 0) |
| 9644 |
1/2✓ Branch 0 taken 624 times.
✗ Branch 1 not taken.
|
624 | sync_error = call_after_sync_hook(final_queue); |
| 9645 | } | ||
| 9646 | |||
| 9647 | /* | ||
| 9648 | Handle sync error after we release all locks in order to avoid deadlocks | ||
| 9649 | */ | ||
| 9650 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2471646 times.
|
2471653 | if (sync_error) |
| 9651 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | handle_binlog_flush_or_sync_error(thd, true /* need_lock_log */, nullptr); |
| 9652 | |||
| 9653 |
3/4✓ Branch 0 taken 2470377 times.
✓ Branch 1 taken 1279 times.
✓ Branch 2 taken 2470382 times.
✗ Branch 3 not taken.
|
2471653 | DEBUG_SYNC(thd, "before_signal_done"); |
| 9654 | /* Commit done so signal all waiting threads */ | ||
| 9655 |
2/4✓ Branch 0 taken 2471657 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2471663 times.
✗ Branch 3 not taken.
|
2471661 | Commit_stage_manager::get_instance().signal_done(final_queue); |
| 9656 |
2/8✓ Branch 0 taken 2471663 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2471663 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
2471663 | DBUG_EXECUTE_IF("block_leader_after_delete", { |
| 9657 | const char action[] = "now SIGNAL leader_proceed"; | ||
| 9658 | assert(!debug_sync_set_action(thd, STRING_WITH_LEN(action))); | ||
| 9659 | };); | ||
| 9660 | |||
| 9661 | /* | ||
| 9662 | Finish the commit before executing a rotate, or run the risk of a | ||
| 9663 | deadlock. We don't need the return value here since it is in | ||
| 9664 | thd->commit_error, which is returned below. | ||
| 9665 | */ | ||
| 9666 |
1/2✓ Branch 0 taken 2471660 times.
✗ Branch 1 not taken.
|
2471663 | (void)finish_commit(thd); |
| 9667 |
3/4✓ Branch 0 taken 2470379 times.
✓ Branch 1 taken 1280 times.
✓ Branch 2 taken 2470381 times.
✗ Branch 3 not taken.
|
2471660 | DEBUG_SYNC(thd, "bgc_after_commit_stage_before_rotation"); |
| 9668 | |||
| 9669 | /* | ||
| 9670 | If we need to rotate, we do it without commit error. | ||
| 9671 | Otherwise the thd->commit_error will be possibly reset. | ||
| 9672 | */ | ||
| 9673 |
6/8✓ Branch 0 taken 2471659 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2471659 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 10850 times.
✓ Branch 5 taken 2460809 times.
✓ Branch 6 taken 9697 times.
✓ Branch 7 taken 2461962 times.
|
2482511 | if (DBUG_EVALUATE_IF("force_rotate", 1, 0) || |
| 9674 |
2/2✓ Branch 0 taken 9697 times.
✓ Branch 1 taken 1153 times.
|
10850 | (do_rotate && thd->commit_error == THD::CE_NONE && |
| 9675 |
1/2✓ Branch 0 taken 9697 times.
✗ Branch 1 not taken.
|
9697 | !is_rotating_caused_by_incident)) { |
| 9676 | /* | ||
| 9677 | Do not force the rotate as several consecutive groups may | ||
| 9678 | request unnecessary rotations. | ||
| 9679 | |||
| 9680 | NOTE: Run purge_logs wo/ holding LOCK_log because it does not | ||
| 9681 | need the mutex. Otherwise causes various deadlocks. | ||
| 9682 | */ | ||
| 9683 | |||
| 9684 |
2/4✓ Branch 0 taken 9695 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9697 times.
✗ Branch 3 not taken.
|
9697 | DEBUG_SYNC(thd, "ready_to_do_rotation"); |
| 9685 | 9696 | bool check_purge = false; | |
| 9686 |
1/2✓ Branch 0 taken 9698 times.
✗ Branch 1 not taken.
|
9696 | mysql_mutex_lock(&LOCK_log); |
| 9687 | /* | ||
| 9688 | If rotate fails then depends on binlog_error_action variable | ||
| 9689 | appropriate action will be taken inside rotate call. | ||
| 9690 | */ | ||
| 9691 |
1/2✓ Branch 0 taken 9698 times.
✗ Branch 1 not taken.
|
9698 | int error = rotate(false, &check_purge); |
| 9692 |
1/2✓ Branch 0 taken 9698 times.
✗ Branch 1 not taken.
|
9698 | mysql_mutex_unlock(&LOCK_log); |
| 9693 | |||
| 9694 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 9690 times.
|
9698 | if (error) |
| 9695 | 8 | thd->commit_error = THD::CE_COMMIT_ERROR; | |
| 9696 |
2/2✓ Branch 0 taken 4961 times.
✓ Branch 1 taken 4729 times.
|
9690 | else if (check_purge) |
| 9697 |
1/2✓ Branch 0 taken 4961 times.
✗ Branch 1 not taken.
|
4961 | auto_purge(); |
| 9698 | } | ||
| 9699 | |||
| 9700 |
6/6✓ Branch 0 taken 28 times.
✓ Branch 1 taken 2471632 times.
✓ Branch 2 taken 25 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 18 times.
✓ Branch 5 taken 2471642 times.
|
2471685 | if (binlog_space_limit && binlog_space_total && |
| 9701 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 7 times.
|
25 | binlog_space_total + m_binlog_file->position() > binlog_space_limit) |
| 9702 |
1/2✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
|
18 | purge_logs_by_size(true); |
| 9703 | |||
| 9704 | /* | ||
| 9705 | flush or sync errors are handled above (using binlog_error_action). | ||
| 9706 | Hence treat only COMMIT_ERRORs as errors. | ||
| 9707 | */ | ||
| 9708 | 2471657 | return thd->commit_error == THD::CE_COMMIT_ERROR; | |
| 9709 | 2584959 | } | |
| 9710 | |||
| 9711 | /** Copy the current binlog coordinates to the variables used for the | ||
| 9712 | not-in-consistent-snapshot case of SHOW STATUS */ | ||
| 9713 | 2502501 | void MYSQL_BIN_LOG::publish_coordinates_for_global_status(void) const { | |
| 9714 | mysql_mutex_assert_owner(&LOCK_log); | ||
| 9715 | |||
| 9716 | 2502501 | mysql_mutex_lock(&LOCK_status); | |
| 9717 | 2502501 | strcpy(binlog_global_snapshot_file, log_file_name); | |
| 9718 | 2502501 | binlog_global_snapshot_position = m_binlog_file->position(); | |
| 9719 | 2502501 | mysql_mutex_unlock(&LOCK_status); | |
| 9720 | 2502501 | } | |
| 9721 | |||
| 9722 | 325 | void MYSQL_BIN_LOG::xlock(void) { | |
| 9723 | 325 | mysql_mutex_lock(&LOCK_log); | |
| 9724 | |||
| 9725 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 325 times.
|
325 | assert(!snapshot_lock_acquired); |
| 9726 | |||
| 9727 | /* | ||
| 9728 | We must ensure that no writes to binlog and no commits to storage engines | ||
| 9729 | occur after function is called for START TRANSACTION FOR CONSISTENT | ||
| 9730 | SNAPSHOT. With binlog_order_commits=1 (the default) flushing to binlog is | ||
| 9731 | performed under the LOCK_log mutex and commits are done under the | ||
| 9732 | LOCK_commit mutex, both in the stage leader thread. So acquiring those 2 | ||
| 9733 | mutexes is sufficient to guarantee atomicity. | ||
| 9734 | |||
| 9735 | With binlog_order_commits=0 commits are performed in parallel by separate | ||
| 9736 | threads with each acquiring a shared lock on LOCK_consistent_snapshot. | ||
| 9737 | |||
| 9738 | binlog_order_commits is a dynamic variable, so we have to keep track what | ||
| 9739 | primitives should be used in xunlock(). | ||
| 9740 | */ | ||
| 9741 |
1/2✓ Branch 0 taken 325 times.
✗ Branch 1 not taken.
|
325 | if (opt_binlog_order_commits) { |
| 9742 | 325 | mysql_mutex_lock(&LOCK_commit); | |
| 9743 | } else { | ||
| 9744 | ✗ | snapshot_lock_acquired = true; | |
| 9745 | ✗ | mysql_rwlock_wrlock(&LOCK_consistent_snapshot); | |
| 9746 | } | ||
| 9747 | 325 | } | |
| 9748 | |||
| 9749 | 325 | void MYSQL_BIN_LOG::xunlock(void) { | |
| 9750 |
1/2✓ Branch 0 taken 325 times.
✗ Branch 1 not taken.
|
325 | if (!snapshot_lock_acquired) { |
| 9751 | 325 | mysql_mutex_unlock(&LOCK_commit); | |
| 9752 | } else { | ||
| 9753 | ✗ | mysql_rwlock_unlock(&LOCK_consistent_snapshot); | |
| 9754 | ✗ | snapshot_lock_acquired = false; | |
| 9755 | } | ||
| 9756 | |||
| 9757 | 325 | mysql_mutex_unlock(&LOCK_log); | |
| 9758 | 325 | } | |
| 9759 | |||
| 9760 | /* | ||
| 9761 | Copy out the non-directory part of binlog position filename for the | ||
| 9762 | `binlog_snapshot_file' status variable, same way as it is done for | ||
| 9763 | SHOW MASTER STATUS. | ||
| 9764 | */ | ||
| 9765 | 140255 | static void set_binlog_snapshot_file(const char *src) { | |
| 9766 | mysql_mutex_assert_owner(&LOCK_status); | ||
| 9767 | |||
| 9768 | 140255 | int dir_len = dirname_length(src); | |
| 9769 | 140255 | strmake(binlog_snapshot_file, src + dir_len, | |
| 9770 | sizeof(binlog_snapshot_file) - 1); | ||
| 9771 | 140255 | } | |
| 9772 | |||
| 9773 | |||
| 9774 | |||
| 9775 | 11 | void MYSQL_BIN_LOG::report_missing_purged_gtids( | |
| 9776 | const Gtid_set *slave_executed_gtid_set, std::string &errmsg) { | ||
| 9777 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | DBUG_TRACE; |
| 9778 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | THD *thd = current_thd; |
| 9779 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | Gtid_set gtid_missing(gtid_state->get_lost_gtids()->get_sid_map()); |
| 9780 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | gtid_missing.add_gtid_set(gtid_state->get_lost_gtids()); |
| 9781 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | gtid_missing.remove_gtid_set(slave_executed_gtid_set); |
| 9782 | |||
| 9783 | 11 | String tmp_uuid; | |
| 9784 | |||
| 9785 | /* Protects thd->user_vars. */ | ||
| 9786 |
2/4✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
|
11 | mysql_mutex_lock(¤t_thd->LOCK_thd_data); |
| 9787 |
3/6✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
|
11 | const auto it = current_thd->user_vars.find("replica_uuid"); |
| 9788 |
4/8✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 11 times.
✗ Branch 7 not taken.
|
11 | if (it != current_thd->user_vars.end() && it->second->length() > 0) { |
| 9789 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | tmp_uuid.copy(it->second->ptr(), it->second->length(), nullptr); |
| 9790 | } | ||
| 9791 |
2/4✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
|
11 | mysql_mutex_unlock(¤t_thd->LOCK_thd_data); |
| 9792 | |||
| 9793 | 11 | char *missing_gtids = nullptr; | |
| 9794 | 11 | char *slave_executed_gtids = nullptr; | |
| 9795 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | gtid_missing.to_string(&missing_gtids); |
| 9796 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | slave_executed_gtid_set->to_string(&slave_executed_gtids); |
| 9797 | |||
| 9798 | /* | ||
| 9799 | Log the information about the missing purged GTIDs to the error log. | ||
| 9800 | */ | ||
| 9801 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | std::ostringstream log_info; |
| 9802 |
3/6✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
|
11 | log_info << "The missing transactions are '" << missing_gtids << "'"; |
| 9803 | |||
| 9804 |
9/18✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 11 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 11 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 11 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 11 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 11 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 11 times.
✗ Branch 17 not taken.
|
11 | LogErr(WARNING_LEVEL, ER_FOUND_MISSING_GTIDS, tmp_uuid.ptr(), |
| 9805 | log_info.str().c_str()); | ||
| 9806 | |||
| 9807 | /* | ||
| 9808 | Send the information about the slave executed GTIDs and missing | ||
| 9809 | purged GTIDs to slave if the message is less than MYSQL_ERRMSG_SIZE. | ||
| 9810 | */ | ||
| 9811 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | std::ostringstream gtid_info; |
| 9812 | gtid_info << "The GTID set sent by the slave is '" << slave_executed_gtids | ||
| 9813 |
5/10✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 11 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 11 times.
✗ Branch 9 not taken.
|
11 | << "', and the missing transactions are '" << missing_gtids << "'"; |
| 9814 |
2/4✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
|
11 | errmsg.assign(ER_THD(thd, ER_MASTER_HAS_PURGED_REQUIRED_GTIDS)); |
| 9815 | |||
| 9816 | /* Don't consider the "%s" in the format string. Subtract 2 from the | ||
| 9817 | total length */ | ||
| 9818 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | int total_length = (errmsg.length() - 2 + gtid_info.str().length()); |
| 9819 | |||
| 9820 |
3/4✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 8 times.
|
11 | DBUG_EXECUTE_IF("simulate_long_missing_gtids", |
| 9821 | { total_length = MYSQL_ERRMSG_SIZE + 1; }); | ||
| 9822 | |||
| 9823 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 8 times.
|
11 | if (total_length > MYSQL_ERRMSG_SIZE) |
| 9824 |
2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
|
3 | gtid_info.str( |
| 9825 | "The GTID sets and the missing purged transactions are too" | ||
| 9826 | " long to print in this message. For more information," | ||
| 9827 | " please see the master's error log or the manual for" | ||
| 9828 | " GTID_SUBTRACT"); | ||
| 9829 | |||
| 9830 | /* Buffer for formatting the message about the missing GTIDs. */ | ||
| 9831 | 11 | char buff[MYSQL_ERRMSG_SIZE] = {0}; | |
| 9832 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | snprintf(buff, MYSQL_ERRMSG_SIZE, errmsg.c_str(), gtid_info.str().c_str()); |
| 9833 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | errmsg.assign(buff); |
| 9834 | |||
| 9835 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | my_free(missing_gtids); |
| 9836 |
1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
|
11 | my_free(slave_executed_gtids); |
| 9837 | 11 | } | |
| 9838 | |||
| 9839 | 1 | void MYSQL_BIN_LOG::report_missing_gtids( | |
| 9840 | const Gtid_set *previous_gtid_set, const Gtid_set *slave_executed_gtid_set, | ||
| 9841 | std::string &errmsg) { | ||
| 9842 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | DBUG_TRACE; |
| 9843 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | THD *thd = current_thd; |
| 9844 | 1 | char *missing_gtids = nullptr; | |
| 9845 | 1 | char *slave_executed_gtids = nullptr; | |
| 9846 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | Gtid_set gtid_missing(slave_executed_gtid_set->get_sid_map()); |
| 9847 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | gtid_missing.add_gtid_set(slave_executed_gtid_set); |
| 9848 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | gtid_missing.remove_gtid_set(previous_gtid_set); |
| 9849 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | gtid_missing.to_string(&missing_gtids); |
| 9850 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | slave_executed_gtid_set->to_string(&slave_executed_gtids); |
| 9851 | |||
| 9852 | 1 | String tmp_uuid; | |
| 9853 | |||
| 9854 | /* Protects thd->user_vars. */ | ||
| 9855 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | mysql_mutex_lock(¤t_thd->LOCK_thd_data); |
| 9856 |
3/6✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
1 | const auto it = current_thd->user_vars.find("replica_uuid"); |
| 9857 |
4/8✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
|
1 | if (it != current_thd->user_vars.end() && it->second->length() > 0) { |
| 9858 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | tmp_uuid.copy(it->second->ptr(), it->second->length(), nullptr); |
| 9859 | } | ||
| 9860 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | mysql_mutex_unlock(¤t_thd->LOCK_thd_data); |
| 9861 | |||
| 9862 | /* | ||
| 9863 | Log the information about the missing purged GTIDs to the error log. | ||
| 9864 | */ | ||
| 9865 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | std::ostringstream log_info; |
| 9866 | log_info << "If the binary log files have been deleted from disk," | ||
| 9867 | " check the consistency of 'GTID_PURGED' variable." | ||
| 9868 | " The missing transactions are '" | ||
| 9869 |
3/6✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
|
1 | << missing_gtids << "'"; |
| 9870 |
9/18✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 times.
✗ Branch 15 not taken.
✓ Branch 16 taken 1 times.
✗ Branch 17 not taken.
|
1 | LogErr(WARNING_LEVEL, ER_FOUND_MISSING_GTIDS, tmp_uuid.ptr(), |
| 9871 | log_info.str().c_str()); | ||
| 9872 | /* | ||
| 9873 | Send the information about the slave executed GTIDs and missing | ||
| 9874 | purged GTIDs to slave if the message is less than MYSQL_ERRMSG_SIZE. | ||
| 9875 | */ | ||
| 9876 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | std::ostringstream gtid_info; |
| 9877 | gtid_info << "The GTID set sent by the slave is '" << slave_executed_gtids | ||
| 9878 |
5/10✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 times.
✗ Branch 9 not taken.
|
1 | << "', and the missing transactions are '" << missing_gtids << "'"; |
| 9879 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | errmsg.assign(ER_THD(thd, ER_MASTER_HAS_PURGED_REQUIRED_GTIDS)); |
| 9880 | |||
| 9881 | /* Don't consider the "%s" in the format string. Subtract 2 from the | ||
| 9882 | total length */ | ||
| 9883 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
|
1 | if ((errmsg.length() - 2 + gtid_info.str().length()) > MYSQL_ERRMSG_SIZE) |
| 9884 | ✗ | gtid_info.str( | |
| 9885 | "The GTID sets and the missing purged transactions are too" | ||
| 9886 | " long to print in this message. For more information," | ||
| 9887 | " please see the master's error log or the manual for" | ||
| 9888 | " GTID_SUBTRACT"); | ||
| 9889 | /* Buffer for formatting the message about the missing GTIDs. */ | ||
| 9890 | 1 | char buff[MYSQL_ERRMSG_SIZE] = {0}; | |
| 9891 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | snprintf(buff, MYSQL_ERRMSG_SIZE, errmsg.c_str(), gtid_info.str().c_str()); |
| 9892 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | errmsg.assign(buff); |
| 9893 | |||
| 9894 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_free(missing_gtids); |
| 9895 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | my_free(slave_executed_gtids); |
| 9896 | 1 | } | |
| 9897 | |||
| 9898 | 1711967 | void MYSQL_BIN_LOG::update_binlog_end_pos(bool need_lock) { | |
| 9899 |
2/2✓ Branch 0 taken 146858 times.
✓ Branch 1 taken 1565109 times.
|
1711967 | if (need_lock) |
| 9900 | 146858 | lock_binlog_end_pos(); | |
| 9901 | else | ||
| 9902 | mysql_mutex_assert_owner(&LOCK_binlog_end_pos); | ||
| 9903 | 1711967 | atomic_binlog_end_pos = m_binlog_file->position(); | |
| 9904 | 1711967 | signal_update(); | |
| 9905 |
2/2✓ Branch 0 taken 146858 times.
✓ Branch 1 taken 1565109 times.
|
1711967 | if (need_lock) unlock_binlog_end_pos(); |
| 9906 | 1711967 | } | |
| 9907 | |||
| 9908 | 2445080 | inline void MYSQL_BIN_LOG::update_binlog_end_pos(const char *file, | |
| 9909 | my_off_t pos) { | ||
| 9910 | 2445080 | lock_binlog_end_pos(); | |
| 9911 |
6/6✓ Branch 0 taken 2445079 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2444953 times.
✓ Branch 3 taken 126 times.
✓ Branch 4 taken 2444953 times.
✓ Branch 5 taken 127 times.
|
2445080 | if (is_active(file) && (pos > atomic_binlog_end_pos)) |
| 9912 | 2444953 | atomic_binlog_end_pos = pos; | |
| 9913 | 2445080 | signal_update(); | |
| 9914 | 2445080 | unlock_binlog_end_pos(); | |
| 9915 | 2445080 | } | |
| 9916 | |||
| 9917 | 2531045 | bool THD::is_binlog_cache_empty(bool is_transactional) const { | |
| 9918 |
1/2✓ Branch 0 taken 2531107 times.
✗ Branch 1 not taken.
|
2531045 | DBUG_TRACE; |
| 9919 | |||
| 9920 | // If opt_bin_log==0, it is not safe to call thd_get_cache_mngr | ||
| 9921 | // because binlog_hton has not been completely set up. | ||
| 9922 | #ifdef WITH_WSREP | ||
| 9923 | #else | ||
| 9924 | assert(opt_bin_log); | ||
| 9925 | #endif /* WITH_WSREP */ | ||
| 9926 |
1/2✓ Branch 0 taken 2531147 times.
✗ Branch 1 not taken.
|
2531107 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(this); |
| 9927 | |||
| 9928 | // cache_mngr is NULL until we call thd->binlog_setup_trx_data, so | ||
| 9929 | // we assert that this has been done. | ||
| 9930 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2531147 times.
|
2531147 | assert(cache_mngr != nullptr); |
| 9931 | |||
| 9932 | binlog_cache_data *cache_data = | ||
| 9933 | 2531147 | cache_mngr->get_binlog_cache_data(is_transactional); | |
| 9934 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2531022 times.
|
2531022 | assert(cache_data != nullptr); |
| 9935 | |||
| 9936 |
1/2✓ Branch 0 taken 2531099 times.
✗ Branch 1 not taken.
|
5062156 | return cache_data->is_binlog_empty(); |
| 9937 | 2531099 | } | |
| 9938 | |||
| 9939 | /* | ||
| 9940 | These functions are placed in this file since they need access to | ||
| 9941 | binlog_hton, which has internal linkage. | ||
| 9942 | */ | ||
| 9943 | |||
| 9944 | 7575548 | int THD::binlog_setup_trx_data() { | |
| 9945 |
1/2✓ Branch 0 taken 7576054 times.
✗ Branch 1 not taken.
|
7575548 | DBUG_TRACE; |
| 9946 |
1/2✓ Branch 0 taken 7576163 times.
✗ Branch 1 not taken.
|
7576054 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(this); |
| 9947 | |||
| 9948 |
2/2✓ Branch 0 taken 7534141 times.
✓ Branch 1 taken 42022 times.
|
7576163 | if (cache_mngr) /* Already set up */ { |
| 9949 | 7533744 | if (Rpl_thd_context::TX_RPL_STAGE_BEGIN == | |
| 9950 |
3/4✓ Branch 0 taken 7533744 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 98287 times.
✓ Branch 3 taken 7435457 times.
|
7534141 | rpl_thd_ctx.get_tx_rpl_delegate_stage_status()) |
| 9951 |
1/2✓ Branch 0 taken 98299 times.
✗ Branch 1 not taken.
|
98287 | rpl_thd_ctx.set_tx_rpl_delegate_stage_status( |
| 9952 | Rpl_thd_context::TX_RPL_STAGE_CACHE_CREATED); | ||
| 9953 | 7533756 | return 0; | |
| 9954 | } | ||
| 9955 | |||
| 9956 |
1/2✓ Branch 0 taken 42029 times.
✗ Branch 1 not taken.
|
42022 | cache_mngr = (binlog_cache_mngr *)my_malloc(key_memory_binlog_cache_mngr, |
| 9957 | sizeof(binlog_cache_mngr), | ||
| 9958 | MYF(MY_ZEROFILL)); | ||
| 9959 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42029 times.
|
42029 | if (!cache_mngr) { |
| 9960 | ✗ | return 1; // Didn't manage to set it up | |
| 9961 | } | ||
| 9962 | |||
| 9963 | 84058 | cache_mngr = new (cache_mngr) | |
| 9964 | binlog_cache_mngr(&binlog_stmt_cache_use, &binlog_stmt_cache_disk_use, | ||
| 9965 |
1/2✓ Branch 0 taken 42029 times.
✗ Branch 1 not taken.
|
42029 | &binlog_cache_use, &binlog_cache_disk_use); |
| 9966 |
2/4✓ Branch 0 taken 42029 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 42029 times.
|
42029 | if (cache_mngr->init()) { |
| 9967 | ✗ | cache_mngr->~binlog_cache_mngr(); | |
| 9968 | ✗ | my_free(cache_mngr); | |
| 9969 | ✗ | return 1; | |
| 9970 | } | ||
| 9971 | 42029 | if (Rpl_thd_context::TX_RPL_STAGE_BEGIN == | |
| 9972 |
3/4✓ Branch 0 taken 42029 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5629 times.
✓ Branch 3 taken 36400 times.
|
42029 | rpl_thd_ctx.get_tx_rpl_delegate_stage_status()) |
| 9973 |
1/2✓ Branch 0 taken 5629 times.
✗ Branch 1 not taken.
|
5629 | rpl_thd_ctx.set_tx_rpl_delegate_stage_status( |
| 9974 | Rpl_thd_context::TX_RPL_STAGE_CACHE_CREATED); | ||
| 9975 | |||
| 9976 |
5/8✓ Branch 0 taken 42029 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 42029 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 42028 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
|
42029 | DBUG_PRINT("debug", ("Set ha_data slot %d to 0x%llx", binlog_hton->slot, |
| 9977 | (ulonglong)cache_mngr)); | ||
| 9978 |
1/2✓ Branch 0 taken 42029 times.
✗ Branch 1 not taken.
|
42029 | thd_set_ha_data(this, binlog_hton, cache_mngr); |
| 9979 | |||
| 9980 | 42029 | return 0; | |
| 9981 | 7575785 | } | |
| 9982 | |||
| 9983 | /** | ||
| 9984 | |||
| 9985 | */ | ||
| 9986 | 4902868 | void register_binlog_handler(THD *thd, bool trx) { | |
| 9987 |
1/2✓ Branch 0 taken 4903040 times.
✗ Branch 1 not taken.
|
4902868 | DBUG_TRACE; |
| 9988 | /* | ||
| 9989 | If this is the first call to this function while processing a statement, | ||
| 9990 | the transactional cache does not have a savepoint defined. So, in what | ||
| 9991 | follows: | ||
| 9992 | . an implicit savepoint is defined; | ||
| 9993 | . callbacks are registered; | ||
| 9994 | . binary log is set as read/write. | ||
| 9995 | |||
| 9996 | The savepoint allows for truncating the trx-cache transactional changes | ||
| 9997 | fail. Callbacks are necessary to flush caches upon committing or rolling | ||
| 9998 | back a statement or a transaction. However, notifications do not happen | ||
| 9999 | if the binary log is set as read/write. | ||
| 10000 | */ | ||
| 10001 |
1/2✓ Branch 0 taken 4903167 times.
✗ Branch 1 not taken.
|
4903040 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd); |
| 10002 |
2/2✓ Branch 0 taken 4852202 times.
✓ Branch 1 taken 50706 times.
|
4903167 | if (cache_mngr->trx_cache.get_prev_position() == MY_OFF_T_UNDEF) { |
| 10003 | /* | ||
| 10004 | Set an implicit savepoint in order to be able to truncate a trx-cache. | ||
| 10005 | */ | ||
| 10006 | 4852202 | my_off_t pos = 0; | |
| 10007 |
1/2✓ Branch 0 taken 4852254 times.
✗ Branch 1 not taken.
|
4852202 | binlog_trans_log_savepos(thd, &pos); |
| 10008 |
1/2✓ Branch 0 taken 4852360 times.
✗ Branch 1 not taken.
|
4852254 | cache_mngr->trx_cache.set_prev_position(pos); |
| 10009 | |||
| 10010 | /* | ||
| 10011 | Set callbacks in order to be able to call commit or rollback. | ||
| 10012 | */ | ||
| 10013 |
3/4✓ Branch 0 taken 3071131 times.
✓ Branch 1 taken 1781229 times.
✓ Branch 2 taken 3071132 times.
✗ Branch 3 not taken.
|
4852360 | if (trx) trans_register_ha(thd, true, binlog_hton, nullptr); |
| 10014 |
1/2✓ Branch 0 taken 4852381 times.
✗ Branch 1 not taken.
|
4852361 | trans_register_ha(thd, false, binlog_hton, nullptr); |
| 10015 | |||
| 10016 | /* | ||
| 10017 | Set the binary log as read/write otherwise callbacks are not called. | ||
| 10018 | */ | ||
| 10019 |
2/4✓ Branch 0 taken 4852325 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4852337 times.
✗ Branch 3 not taken.
|
4852381 | thd->get_ha_data(binlog_hton->slot)->ha_info[0].set_trx_read_write(); |
| 10020 | } | ||
| 10021 | 4903043 | } | |
| 10022 | |||
| 10023 | /** | ||
| 10024 | Function to start a statement and optionally a transaction for the | ||
| 10025 | binary log. | ||
| 10026 | |||
| 10027 | This function does three things: | ||
| 10028 | - Starts a transaction if not in autocommit mode or if a BEGIN | ||
| 10029 | statement has been seen. | ||
| 10030 | |||
| 10031 | - Start a statement transaction to allow us to truncate the cache. | ||
| 10032 | |||
| 10033 | - Save the current binlog position so that we can roll back the | ||
| 10034 | statement by truncating the cache. | ||
| 10035 | |||
| 10036 | We only update the saved position if the old one was undefined, | ||
| 10037 | the reason is that there are some cases (e.g., for CREATE-SELECT) | ||
| 10038 | where the position is saved twice (e.g., both in | ||
| 10039 | Query_result_create::prepare() and THD::binlog_write_table_map()), but | ||
| 10040 | we should use the first. This means that calls to this function | ||
| 10041 | can be used to start the statement before the first table map | ||
| 10042 | event, to include some extra events. | ||
| 10043 | |||
| 10044 | Note however that IMMEDIATE_LOGGING implies that the statement is | ||
| 10045 | written without BEGIN/COMMIT. | ||
| 10046 | |||
| 10047 | @param thd Thread variable | ||
| 10048 | @param start_event The first event requested to be written into the | ||
| 10049 | binary log | ||
| 10050 | */ | ||
| 10051 | 4994172 | static int binlog_start_trans_and_stmt(THD *thd, Log_event *start_event) { | |
| 10052 |
1/2✓ Branch 0 taken 4994328 times.
✗ Branch 1 not taken.
|
4994172 | DBUG_TRACE; |
| 10053 | |||
| 10054 | /* | ||
| 10055 | Initialize the cache manager if this was not done yet. | ||
| 10056 | */ | ||
| 10057 |
2/4✓ Branch 0 taken 4994237 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4994237 times.
|
4994328 | if (thd->binlog_setup_trx_data()) return 1; |
| 10058 | |||
| 10059 | /* | ||
| 10060 | Retrieve the appropriated cache. | ||
| 10061 | */ | ||
| 10062 | 4994237 | bool is_transactional = start_event->is_using_trans_cache(); | |
| 10063 |
1/2✓ Branch 0 taken 4994405 times.
✗ Branch 1 not taken.
|
4994196 | binlog_cache_mngr *cache_mngr = thd_get_cache_mngr(thd); |
| 10064 | binlog_cache_data *cache_data = | ||
| 10065 | 4994405 | cache_mngr->get_binlog_cache_data(is_transactional); | |
| 10066 | |||
| 10067 | /* | ||
| 10068 | If the event is requesting immediate logging, there is no need to go | ||
| 10069 | further down and set savepoint and register callbacks. | ||
| 10070 | */ | ||
| 10071 |
2/2✓ Branch 0 taken 91302 times.
✓ Branch 1 taken 4903047 times.
|
4994279 | if (start_event->is_using_immediate_logging()) return 0; |
| 10072 | |||
| 10073 |
1/2✓ Branch 0 taken 4903103 times.
✗ Branch 1 not taken.
|
4903047 | register_binlog_handler(thd, thd->in_multi_stmt_transaction_mode()); |
| 10074 | |||
| 10075 | /* Transactional DDL is logged traditionally without BEGIN. */ | ||
| 10076 |
2/2✓ Branch 0 taken 317991 times.
✓ Branch 1 taken 4584872 times.
|
4903103 | if (is_atomic_ddl_event(start_event)) return 0; |
| 10077 | |||
| 10078 | /* | ||
| 10079 | If the cache is empty log "BEGIN" at the beginning of every transaction. | ||
| 10080 | Here, a transaction is either a BEGIN..COMMIT/ROLLBACK block or a single | ||
| 10081 | statement in autocommit mode. | ||
| 10082 | */ | ||
| 10083 |
3/4✓ Branch 0 taken 4585063 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2136763 times.
✓ Branch 3 taken 2448300 times.
|
4584872 | if (cache_data->is_binlog_empty()) { |
| 10084 | static const char begin[] = "BEGIN"; | ||
| 10085 | 2136763 | const char *query = nullptr; | |
| 10086 | char buf[XID::ser_buf_size]; | ||
| 10087 | char xa_start[sizeof("XA START") + 1 + sizeof(buf)]; | ||
| 10088 | 2136763 | XID_STATE *xs = thd->get_transaction()->xid_state(); | |
| 10089 | 2136755 | int qlen = sizeof(begin) - 1; | |
| 10090 | |||
| 10091 |
6/6✓ Branch 0 taken 1738010 times.
✓ Branch 1 taken 398745 times.
✓ Branch 2 taken 664 times.
✓ Branch 3 taken 1737349 times.
✓ Branch 4 taken 664 times.
✓ Branch 5 taken 2136094 times.
|
2136755 | if (is_transactional && xs->has_state(XID_STATE::XA_ACTIVE)) { |
| 10092 | /* | ||
| 10093 | XA-prepare logging case. | ||
| 10094 | */ | ||
| 10095 | 664 | qlen = sprintf(xa_start, "XA START %s", xs->get_xid()->serialize(buf)); | |
| 10096 | 664 | query = xa_start; | |
| 10097 | } else { | ||
| 10098 | /* | ||
| 10099 | Regular transaction case. | ||
| 10100 | */ | ||
| 10101 | 2136094 | query = begin; | |
| 10102 | } | ||
| 10103 | |||
| 10104 | Query_log_event qinfo(thd, query, qlen, is_transactional, false, true, 0, | ||
| 10105 |
1/2✓ Branch 0 taken 2136608 times.
✗ Branch 1 not taken.
|
2136758 | true); |
| 10106 |
2/4✓ Branch 0 taken 2136762 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2136762 times.
|
2136608 | if (cache_data->write_event(&qinfo)) return 1; |
| 10107 |
1/2✓ Branch 0 taken 2136448 times.
✗ Branch 1 not taken.
|
2136762 | } |
| 10108 | |||
| 10109 | 4584748 | return 0; | |
| 10110 | 4994007 | } | |
| 10111 | |||
| 10112 | /** | ||
| 10113 | This function writes a table map to the binary log. | ||
| 10114 | Note that in order to keep the signature uniform with related methods, | ||
| 10115 | we use a redundant parameter to indicate whether a transactional table | ||
| 10116 | was changed or not. | ||
| 10117 | Sometimes it will write a Rows_query_log_event into binary log before | ||
| 10118 | the table map too. | ||
| 10119 | |||
| 10120 | @param table a pointer to the table. | ||
| 10121 | @param is_transactional @c true indicates a transactional table, | ||
| 10122 | otherwise @c false a non-transactional. | ||
| 10123 | @param binlog_rows_query @c true indicates a Rows_query log event | ||
| 10124 | will be binlogged before table map, | ||
| 10125 | otherwise @c false indicates it will not | ||
| 10126 | be binlogged. | ||
| 10127 | @return | ||
| 10128 | nonzero if an error pops up when writing the table map event | ||
| 10129 | or the Rows_query log event. | ||
| 10130 | */ | ||
| 10131 | 4247015 | int THD::binlog_write_table_map(TABLE *table, bool is_transactional, | |
| 10132 | bool binlog_rows_query) { | ||
| 10133 | int error; | ||
| 10134 |
1/2✓ Branch 0 taken 4247161 times.
✗ Branch 1 not taken.
|
4247015 | DBUG_TRACE; |
| 10135 |
5/8✓ Branch 0 taken 4247109 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4247126 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 23 times.
✓ Branch 5 taken 4247103 times.
✓ Branch 6 taken 23 times.
✗ Branch 7 not taken.
|
4247161 | DBUG_PRINT("enter", ("table: %p (%s: #%llu)", table, table->s->table_name.str, |
| 10136 | table->s->table_map_id.id())); | ||
| 10137 | |||
| 10138 | /* Pre-conditions */ | ||
| 10139 | #ifdef WITH_WSREP | ||
| 10140 |
11/12✓ Branch 0 taken 4247104 times.
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 108242 times.
✓ Branch 3 taken 4138862 times.
✓ Branch 4 taken 108240 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 108238 times.
✓ Branch 7 taken 2 times.
✓ Branch 8 taken 108173 times.
✓ Branch 9 taken 65 times.
✓ Branch 10 taken 4247073 times.
✗ Branch 11 not taken.
|
4247126 | assert(is_current_stmt_binlog_format_row() && |
| 10141 | (WSREP_EMULATE_BINLOG_NNULL(this) || mysql_bin_log.is_open())); | ||
| 10142 | #else | ||
| 10143 | assert(is_current_stmt_binlog_format_row() && mysql_bin_log.is_open()); | ||
| 10144 | #endif /* WITH_WSREP */ | ||
| 10145 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4247039 times.
|
4247138 | assert(table->s->table_map_id.is_valid()); |
| 10146 | |||
| 10147 | 4247039 | Table_map_log_event the_event(this, table, table->s->table_map_id, | |
| 10148 |
1/2✓ Branch 0 taken 4247029 times.
✗ Branch 1 not taken.
|
4247039 | is_transactional); |
| 10149 | |||
| 10150 |
1/2✓ Branch 0 taken 4247149 times.
✗ Branch 1 not taken.
|
4247029 | binlog_start_trans_and_stmt(this, &the_event); |
| 10151 | |||
| 10152 |
1/2✓ Branch 0 taken 4247164 times.
✗ Branch 1 not taken.
|
4247149 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(this); |
| 10153 | |||
| 10154 | binlog_cache_data *cache_data = | ||
| 10155 | 4247164 | cache_mngr->get_binlog_cache_data(is_transactional); | |
| 10156 | |||
| 10157 |
7/8✓ Branch 0 taken 175 times.
✓ Branch 1 taken 4246983 times.
✓ Branch 2 taken 77 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 75 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 75 times.
✓ Branch 7 taken 4246985 times.
|
4247158 | if (binlog_rows_query && this->query().str) { |
| 10158 | /* Write the Rows_query_log_event into binlog before the table map */ | ||
| 10159 | 150 | Rows_query_log_event rows_query_ev(this, this->query().str, | |
| 10160 |
3/6✓ Branch 0 taken 75 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 75 times.
✗ Branch 5 not taken.
|
75 | this->query().length); |
| 10161 |
2/4✓ Branch 0 taken 75 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 75 times.
|
75 | if ((error = cache_data->write_event(&rows_query_ev))) return error; |
| 10162 |
1/2✓ Branch 0 taken 75 times.
✗ Branch 1 not taken.
|
75 | } |
| 10163 | |||
| 10164 |
2/4✓ Branch 0 taken 4247066 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4247066 times.
|
4247060 | if ((error = cache_data->write_event(&the_event))) return error; |
| 10165 | |||
| 10166 | 4247066 | binlog_table_maps++; | |
| 10167 | 4247066 | return 0; | |
| 10168 | 4247066 | } | |
| 10169 | |||
| 10170 | /** | ||
| 10171 | This function retrieves a pending row event from a cache which is | ||
| 10172 | specified through the parameter @c is_transactional. Respectively, when it | ||
| 10173 | is @c true, the pending event is returned from the transactional cache. | ||
| 10174 | Otherwise from the non-transactional cache. | ||
| 10175 | |||
| 10176 | @param is_transactional @c true indicates a transactional cache, | ||
| 10177 | otherwise @c false a non-transactional. | ||
| 10178 | @return | ||
| 10179 | The row event if any. | ||
| 10180 | */ | ||
| 10181 | 89193148 | Rows_log_event *THD::binlog_get_pending_rows_event( | |
| 10182 | bool is_transactional) const { | ||
| 10183 | 89193148 | Rows_log_event *rows = nullptr; | |
| 10184 | 89193148 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(this); | |
| 10185 | |||
| 10186 | /* | ||
| 10187 | This is less than ideal, but here's the story: If there is no cache_mngr, | ||
| 10188 | prepare_pending_rows_event() has never been called (since the cache_mngr | ||
| 10189 | is set up there). In that case, we just return NULL. | ||
| 10190 | */ | ||
| 10191 |
2/2✓ Branch 0 taken 68282456 times.
✓ Branch 1 taken 20913335 times.
|
89195791 | if (cache_mngr) { |
| 10192 | binlog_cache_data *cache_data = | ||
| 10193 | 68282456 | cache_mngr->get_binlog_cache_data(is_transactional); | |
| 10194 | |||
| 10195 | 68281033 | rows = cache_data->pending(); | |
| 10196 | } | ||
| 10197 | 89195569 | return (rows); | |
| 10198 | } | ||
| 10199 | |||
| 10200 | /** | ||
| 10201 | @param db_param db name c-string to be inserted into alphabetically sorted | ||
| 10202 | THD::binlog_accessed_db_names list. | ||
| 10203 | |||
| 10204 | Note, that space for both the data and the node | ||
| 10205 | struct are allocated in THD::main_mem_root. | ||
| 10206 | The list lasts for the top-level query time and is reset | ||
| 10207 | in @c THD::cleanup_after_query(). | ||
| 10208 | */ | ||
| 10209 | 1509647 | void THD::add_to_binlog_accessed_dbs(const char *db_param) { | |
| 10210 | char *after_db; | ||
| 10211 | /* | ||
| 10212 | binlog_accessed_db_names list is to maintain the database | ||
| 10213 | names which are referenced in a given command. | ||
| 10214 | Prior to bug 17806014 fix, 'main_mem_root' memory root used | ||
| 10215 | to store this list. The 'main_mem_root' scope is till the end | ||
| 10216 | of the query. Hence it caused increasing memory consumption | ||
| 10217 | problem in big procedures like the ones mentioned below. | ||
| 10218 | Eg: CALL p1() where p1 is having 1,00,000 create and drop tables. | ||
| 10219 | 'main_mem_root' is freed only at the end of the command CALL p1()'s | ||
| 10220 | execution. But binlog_accessed_db_names list scope is only till the | ||
| 10221 | individual statements specified the procedure(create/drop statements). | ||
| 10222 | Hence the memory allocated in 'main_mem_root' was left uncleared | ||
| 10223 | until the p1's completion, even though it is not required after | ||
| 10224 | completion of individual statements. | ||
| 10225 | |||
| 10226 | Instead of using 'main_mem_root' whose scope is complete query execution, | ||
| 10227 | now the memroot is changed to use 'thd->mem_root' whose scope is until the | ||
| 10228 | individual statement in CALL p1(). 'thd->mem_root' is set to | ||
| 10229 | 'execute_mem_root' in the context of procedure and it's scope is till the | ||
| 10230 | individual statement in CALL p1() and thd->memroot is equal to | ||
| 10231 | 'main_mem_root' in the context of a normal 'top level query'. | ||
| 10232 | |||
| 10233 | Eg: a) create table t1(i int); => If this function is called while | ||
| 10234 | processing this statement, thd->memroot is equal to &main_mem_root | ||
| 10235 | which will be freed immediately after executing this statement. | ||
| 10236 | b) CALL p1() -> p1 contains create table t1(i int); => If this function | ||
| 10237 | is called while processing create table statement which is inside | ||
| 10238 | a stored procedure, then thd->memroot is equal to 'execute_mem_root' | ||
| 10239 | which will be freed immediately after executing this statement. | ||
| 10240 | In both a and b case, thd->memroot will be freed immediately and will not | ||
| 10241 | increase memory consumption. | ||
| 10242 | |||
| 10243 | A special case(stored functions/triggers): | ||
| 10244 | Consider the following example: | ||
| 10245 | create function f1(i int) returns int | ||
| 10246 | begin | ||
| 10247 | insert into db1.t1 values (1); | ||
| 10248 | insert into db2.t1 values (2); | ||
| 10249 | end; | ||
| 10250 | When we are processing SELECT f1(), the list should contain db1, db2 names. | ||
| 10251 | Since thd->mem_root contains 'execute_mem_root' in the context of | ||
| 10252 | stored function, the mem root will be freed after adding db1 in | ||
| 10253 | the list and when we are processing the second statement and when we try | ||
| 10254 | to add 'db2' in the db1's list, it will lead to crash as db1's memory | ||
| 10255 | is already freed. To handle this special case, if in_sub_stmt is set | ||
| 10256 | (which is true in case of stored functions/triggers), we use &main_mem_root, | ||
| 10257 | if not set we will use thd->memroot which changes it's value to | ||
| 10258 | 'execute_mem_root' or '&main_mem_root' depends on the context. | ||
| 10259 | */ | ||
| 10260 |
2/2✓ Branch 0 taken 359 times.
✓ Branch 1 taken 1509288 times.
|
1509647 | MEM_ROOT *db_mem_root = in_sub_stmt ? &main_mem_root : mem_root; |
| 10261 | |||
| 10262 |
2/2✓ Branch 0 taken 1189967 times.
✓ Branch 1 taken 319680 times.
|
1509647 | if (!binlog_accessed_db_names) |
| 10263 |
1/2✓ Branch 0 taken 1189867 times.
✗ Branch 1 not taken.
|
1189967 | binlog_accessed_db_names = new (db_mem_root) List<char>; |
| 10264 | |||
| 10265 |
2/2✓ Branch 0 taken 384 times.
✓ Branch 1 taken 1509076 times.
|
1509460 | if (binlog_accessed_db_names->elements > MAX_DBS_IN_EVENT_MTS) { |
| 10266 | 384 | push_warning_printf( | |
| 10267 | this, Sql_condition::SL_WARNING, ER_MTS_UPDATED_DBS_GREATER_MAX, | ||
| 10268 | ER_THD(this, ER_MTS_UPDATED_DBS_GREATER_MAX), MAX_DBS_IN_EVENT_MTS); | ||
| 10269 | 384 | return; | |
| 10270 | } | ||
| 10271 | |||
| 10272 | 1509076 | after_db = strdup_root(db_mem_root, db_param); | |
| 10273 | |||
| 10274 | /* | ||
| 10275 | sorted insertion is implemented with first rearranging data | ||
| 10276 | (pointer to char*) of the links and final appending of the least | ||
| 10277 | ordered data to create a new link in the list. | ||
| 10278 | */ | ||
| 10279 |
2/2✓ Branch 0 taken 319505 times.
✓ Branch 1 taken 1189916 times.
|
1509421 | if (binlog_accessed_db_names->elements != 0) { |
| 10280 |
1/2✓ Branch 0 taken 319505 times.
✗ Branch 1 not taken.
|
319505 | List_iterator<char> it(*get_binlog_accessed_db_names()); |
| 10281 | |||
| 10282 |
2/2✓ Branch 0 taken 391406 times.
✓ Branch 1 taken 15286 times.
|
406692 | while (it++) { |
| 10283 | 391406 | char *swap = nullptr; | |
| 10284 | 391406 | char **ref_cur_db = it.ref(); | |
| 10285 | 391406 | int cmp = strcmp(after_db, *ref_cur_db); | |
| 10286 | |||
| 10287 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 391406 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
391406 | assert(!swap || cmp < 0); |
| 10288 | |||
| 10289 |
2/2✓ Branch 0 taken 304219 times.
✓ Branch 1 taken 87187 times.
|
391406 | if (cmp == 0) { |
| 10290 | 304219 | after_db = nullptr; /* dup to ignore */ | |
| 10291 | 304219 | break; | |
| 10292 |
3/4✓ Branch 0 taken 87187 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18773 times.
✓ Branch 3 taken 68414 times.
|
87187 | } else if (swap || cmp > 0) { |
| 10293 | 18773 | swap = *ref_cur_db; | |
| 10294 | 18773 | *ref_cur_db = after_db; | |
| 10295 | 18773 | after_db = swap; | |
| 10296 | } | ||
| 10297 | } | ||
| 10298 | } | ||
| 10299 |
2/2✓ Branch 0 taken 1204932 times.
✓ Branch 1 taken 304489 times.
|
1509421 | if (after_db) binlog_accessed_db_names->push_back(after_db, db_mem_root); |
| 10300 | } | ||
| 10301 | |||
| 10302 | /* | ||
| 10303 | Tells if two (or more) tables have auto_increment columns and we want to | ||
| 10304 | lock those tables with a write lock. | ||
| 10305 | |||
| 10306 | SYNOPSIS | ||
| 10307 | has_two_write_locked_tables_with_auto_increment | ||
| 10308 | tables Table list | ||
| 10309 | |||
| 10310 | NOTES: | ||
| 10311 | Call this function only when you have established the list of all tables | ||
| 10312 | which you'll want to update (including stored functions, triggers, views | ||
| 10313 | inside your statement). | ||
| 10314 | */ | ||
| 10315 | |||
| 10316 | 928524 | static bool has_write_table_with_auto_increment(TABLE_LIST *tables) { | |
| 10317 |
2/2✓ Branch 0 taken 2060589 times.
✓ Branch 1 taken 815054 times.
|
2875643 | for (TABLE_LIST *table = tables; table; table = table->next_global) { |
| 10318 | /* we must do preliminary checks as table->table may be NULL */ | ||
| 10319 |
6/6✓ Branch 0 taken 1831810 times.
✓ Branch 1 taken 229206 times.
✓ Branch 2 taken 771863 times.
✓ Branch 3 taken 1059947 times.
✓ Branch 4 taken 113898 times.
✓ Branch 5 taken 1947119 times.
|
2832453 | if (!table->is_placeholder() && table->table->found_next_number_field && |
| 10320 |
2/2✓ Branch 0 taken 113898 times.
✓ Branch 1 taken 657966 times.
|
771863 | (table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE)) |
| 10321 | 113898 | return true; | |
| 10322 | } | ||
| 10323 | |||
| 10324 | 815054 | return false; | |
| 10325 | } | ||
| 10326 | |||
| 10327 | /* | ||
| 10328 | checks if we have select tables in the table list and write tables | ||
| 10329 | with auto-increment column. | ||
| 10330 | |||
| 10331 | SYNOPSIS | ||
| 10332 | has_two_write_locked_tables_with_auto_increment_and_query_block | ||
| 10333 | tables Table list | ||
| 10334 | |||
| 10335 | RETURN VALUES | ||
| 10336 | |||
| 10337 | -true if the table list has at least one table with auto-increment column | ||
| 10338 | and at least one table to select from. | ||
| 10339 | -false otherwise | ||
| 10340 | */ | ||
| 10341 | |||
| 10342 | 919096 | static bool has_write_table_with_auto_increment_and_query_block( | |
| 10343 | TABLE_LIST *tables) { | ||
| 10344 | 919096 | bool has_query_block = false; | |
| 10345 | 919096 | bool has_auto_increment_tables = has_write_table_with_auto_increment(tables); | |
| 10346 |
2/2✓ Branch 0 taken 1350793 times.
✓ Branch 1 taken 446766 times.
|
1797559 | for (TABLE_LIST *table = tables; table; table = table->next_global) { |
| 10347 |
4/4✓ Branch 0 taken 1122659 times.
✓ Branch 1 taken 228213 times.
✓ Branch 2 taken 472816 times.
✓ Branch 3 taken 878013 times.
|
2473409 | if (!table->is_placeholder() && |
| 10348 |
2/2✓ Branch 0 taken 472817 times.
✓ Branch 1 taken 649799 times.
|
1122659 | (table->lock_descriptor().type <= TL_READ_NO_INSERT)) { |
| 10349 | 472816 | has_query_block = true; | |
| 10350 | 472816 | break; | |
| 10351 | } | ||
| 10352 | } | ||
| 10353 |
4/4✓ Branch 0 taken 472818 times.
✓ Branch 1 taken 446764 times.
✓ Branch 2 taken 418 times.
✓ Branch 3 taken 472400 times.
|
919582 | return (has_query_block && has_auto_increment_tables); |
| 10354 | } | ||
| 10355 | |||
| 10356 | /* | ||
| 10357 | Tells if there is a table whose auto_increment column is a part | ||
| 10358 | of a compound primary key while is not the first column in | ||
| 10359 | the table definition. | ||
| 10360 | |||
| 10361 | @param tables Table list | ||
| 10362 | |||
| 10363 | @return true if the table exists, fais if does not. | ||
| 10364 | */ | ||
| 10365 | |||
| 10366 | 919071 | static bool has_write_table_auto_increment_not_first_in_pk(TABLE_LIST *tables) { | |
| 10367 |
2/2✓ Branch 0 taken 2050312 times.
✓ Branch 1 taken 919564 times.
|
2969876 | for (TABLE_LIST *table = tables; table; table = table->next_global) { |
| 10368 | /* we must do preliminary checks as table->table may be NULL */ | ||
| 10369 |
2/2✓ Branch 0 taken 772132 times.
✓ Branch 1 taken 1049541 times.
|
3871985 | if (!table->is_placeholder() && table->table->found_next_number_field && |
| 10370 |
6/6✓ Branch 0 taken 1821673 times.
✓ Branch 1 taken 229151 times.
✓ Branch 2 taken 113920 times.
✓ Branch 3 taken 658205 times.
✓ Branch 4 taken 12 times.
✓ Branch 5 taken 2050805 times.
|
3986417 | (table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE) && |
| 10371 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 113908 times.
|
113920 | table->table->s->next_number_keypart != 0) |
| 10372 | 12 | return true; | |
| 10373 | } | ||
| 10374 | |||
| 10375 | 919564 | return false; | |
| 10376 | } | ||
| 10377 | |||
| 10378 | /** | ||
| 10379 | Checks if a table has a column with a non-deterministic DEFAULT expression. | ||
| 10380 | */ | ||
| 10381 | 10856 | static bool has_nondeterministic_default(const TABLE *table) { | |
| 10382 | 21712 | return std::any_of( | |
| 10383 | 10856 | table->field, table->field + table->s->fields, [](const Field *field) { | |
| 10384 |
4/4✓ Branch 0 taken 27 times.
✓ Branch 1 taken 19632 times.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 14 times.
|
19686 | return field->m_default_val_expr != nullptr && |
| 10385 | 19686 | field->m_default_val_expr->get_stmt_unsafe_flags() != 0; | |
| 10386 | 10856 | }); | |
| 10387 | } | ||
| 10388 | |||
| 10389 | /** | ||
| 10390 | Checks if a TABLE_LIST contains a table that has been opened for writing, and | ||
| 10391 | that has a column with a non-deterministic DEFAULT expression. | ||
| 10392 | */ | ||
| 10393 | 9434 | static bool has_write_table_with_nondeterministic_default( | |
| 10394 | const TABLE_LIST *tables) { | ||
| 10395 |
2/2✓ Branch 0 taken 11338 times.
✓ Branch 1 taken 9421 times.
|
20759 | for (const TABLE_LIST *table = tables; table != nullptr; |
| 10396 | 11325 | table = table->next_global) { | |
| 10397 | /* we must do preliminary checks as table->table may be NULL */ | ||
| 10398 | 11338 | if (!table->is_placeholder() && | |
| 10399 |
6/6✓ Branch 0 taken 11272 times.
✓ Branch 1 taken 66 times.
✓ Branch 2 taken 10856 times.
✓ Branch 3 taken 416 times.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 11325 times.
|
22194 | table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE && |
| 10400 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 10843 times.
|
10856 | has_nondeterministic_default(table->table)) |
| 10401 | 13 | return true; | |
| 10402 | } | ||
| 10403 | 9421 | return false; | |
| 10404 | } | ||
| 10405 | |||
| 10406 | /** | ||
| 10407 | Checks if we have reads from ACL tables in table list. | ||
| 10408 | |||
| 10409 | @param thd Current thread | ||
| 10410 | @param tl_list TABLE_LIST used by current command. | ||
| 10411 | |||
| 10412 | @returns true, if we statement is unsafe, otherwise false. | ||
| 10413 | */ | ||
| 10414 | 919025 | static bool has_acl_table_read(THD *thd, const TABLE_LIST *tl_list) { | |
| 10415 |
2/2✓ Branch 0 taken 2050265 times.
✓ Branch 1 taken 918663 times.
|
2968928 | for (const TABLE_LIST *tl = tl_list; tl != nullptr; tl = tl->next_global) { |
| 10416 |
4/4✓ Branch 0 taken 404537 times.
✓ Branch 1 taken 1646226 times.
✓ Branch 2 taken 868 times.
✓ Branch 3 taken 2049903 times.
|
2454810 | if (is_acl_table_in_non_LTM(tl, thd->locked_tables_mode) && |
| 10417 |
2/2✓ Branch 0 taken 403661 times.
✓ Branch 1 taken 876 times.
|
404537 | (tl->lock_descriptor().type == TL_READ_DEFAULT || |
| 10418 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 403677 times.
|
403661 | tl->lock_descriptor().type == TL_READ_HIGH_PRIORITY)) |
| 10419 | 868 | return true; | |
| 10420 | } | ||
| 10421 | 918663 | return false; | |
| 10422 | } | ||
| 10423 | |||
| 10424 | /* | ||
| 10425 | Function to check whether the table in query uses a fulltext parser | ||
| 10426 | plugin or not. | ||
| 10427 | |||
| 10428 | @param s - table share pointer. | ||
| 10429 | |||
| 10430 | @retval true - The table uses fulltext parser plugin. | ||
| 10431 | @retval false - Otherwise. | ||
| 10432 | */ | ||
| 10433 | 5062919 | static bool inline fulltext_unsafe_set(TABLE_SHARE *s) { | |
| 10434 |
2/2✓ Branch 0 taken 4242669 times.
✓ Branch 1 taken 5061655 times.
|
9304324 | for (unsigned int i = 0; i < s->keys; i++) { |
| 10435 |
5/6✓ Branch 0 taken 1264 times.
✓ Branch 1 taken 4241405 times.
✓ Branch 2 taken 1264 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1264 times.
✓ Branch 5 taken 4241405 times.
|
4242669 | if ((s->key_info[i].flags & HA_USES_PARSER) && s->keys_in_use.is_set(i)) |
| 10436 | 1264 | return true; | |
| 10437 | } | ||
| 10438 | 5061655 | return false; | |
| 10439 | } | ||
| 10440 | #ifndef NDEBUG | ||
| 10441 | 156 | const char *get_locked_tables_mode_name( | |
| 10442 | enum_locked_tables_mode locked_tables_mode) { | ||
| 10443 |
2/5✓ Branch 0 taken 151 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
156 | switch (locked_tables_mode) { |
| 10444 | 151 | case LTM_NONE: | |
| 10445 | 151 | return "LTM_NONE"; | |
| 10446 | ✗ | case LTM_LOCK_TABLES: | |
| 10447 | ✗ | return "LTM_LOCK_TABLES"; | |
| 10448 | 5 | case LTM_PRELOCKED: | |
| 10449 | 5 | return "LTM_PRELOCKED"; | |
| 10450 | ✗ | case LTM_PRELOCKED_UNDER_LOCK_TABLES: | |
| 10451 | ✗ | return "LTM_PRELOCKED_UNDER_LOCK_TABLES"; | |
| 10452 | ✗ | default: | |
| 10453 | ✗ | return "Unknown table lock mode"; | |
| 10454 | } | ||
| 10455 | } | ||
| 10456 | #endif | ||
| 10457 | |||
| 10458 | /** | ||
| 10459 | Decide on logging format to use for the statement and issue errors | ||
| 10460 | or warnings as needed. The decision depends on the following | ||
| 10461 | parameters: | ||
| 10462 | |||
| 10463 | - The logging mode, i.e., the value of binlog_format. Can be | ||
| 10464 | statement, mixed, or row. | ||
| 10465 | |||
| 10466 | - The type of statement. There are three types of statements: | ||
| 10467 | "normal" safe statements; unsafe statements; and row injections. | ||
| 10468 | An unsafe statement is one that, if logged in statement format, | ||
| 10469 | might produce different results when replayed on the slave (e.g., | ||
| 10470 | queries with a LIMIT clause). A row injection is either a BINLOG | ||
| 10471 | statement, or a row event executed by the slave's SQL thread. | ||
| 10472 | |||
| 10473 | - The capabilities of tables modified by the statement. The | ||
| 10474 | *capabilities vector* for a table is a set of flags associated | ||
| 10475 | with the table. Currently, it only includes two flags: *row | ||
| 10476 | capability flag* and *statement capability flag*. | ||
| 10477 | |||
| 10478 | The row capability flag is set if and only if the engine can | ||
| 10479 | handle row-based logging. The statement capability flag is set if | ||
| 10480 | and only if the table can handle statement-based logging. | ||
| 10481 | |||
| 10482 | Decision table for logging format | ||
| 10483 | --------------------------------- | ||
| 10484 | |||
| 10485 | The following table summarizes how the format and generated | ||
| 10486 | warning/error depends on the tables' capabilities, the statement | ||
| 10487 | type, and the current binlog_format. | ||
| 10488 | |||
| 10489 | Row capable N NNNNNNNNN YYYYYYYYY YYYYYYYYY | ||
| 10490 | Statement capable N YYYYYYYYY NNNNNNNNN YYYYYYYYY | ||
| 10491 | |||
| 10492 | Statement type * SSSUUUIII SSSUUUIII SSSUUUIII | ||
| 10493 | |||
| 10494 | binlog_format * SMRSMRSMR SMRSMRSMR SMRSMRSMR | ||
| 10495 | |||
| 10496 | Logged format - SS-S----- -RR-RR-RR SRRSRR-RR | ||
| 10497 | Warning/Error 1 --2732444 5--5--6-- ---7--6-- | ||
| 10498 | |||
| 10499 | Legend | ||
| 10500 | ------ | ||
| 10501 | |||
| 10502 | Row capable: N - Some table not row-capable, Y - All tables row-capable | ||
| 10503 | Stmt capable: N - Some table not stmt-capable, Y - All tables stmt-capable | ||
| 10504 | Statement type: (S)afe, (U)nsafe, or Row (I)njection | ||
| 10505 | binlog_format: (S)TATEMENT, (M)IXED, or (R)OW | ||
| 10506 | Logged format: (S)tatement or (R)ow | ||
| 10507 | Warning/Error: Warnings and error messages are as follows: | ||
| 10508 | |||
| 10509 | 1. Error: Cannot execute statement: binlogging impossible since both | ||
| 10510 | row-incapable engines and statement-incapable engines are | ||
| 10511 | involved. | ||
| 10512 | |||
| 10513 | 2. Error: Cannot execute statement: binlogging impossible since | ||
| 10514 | BINLOG_FORMAT = ROW and at least one table uses a storage engine | ||
| 10515 | limited to statement-logging. | ||
| 10516 | |||
| 10517 | 3. Error: Cannot execute statement: binlogging of unsafe statement | ||
| 10518 | is impossible when storage engine is limited to statement-logging | ||
| 10519 | and BINLOG_FORMAT = MIXED. | ||
| 10520 | |||
| 10521 | 4. Error: Cannot execute row injection: binlogging impossible since | ||
| 10522 | at least one table uses a storage engine limited to | ||
| 10523 | statement-logging. | ||
| 10524 | |||
| 10525 | 5. Error: Cannot execute statement: binlogging impossible since | ||
| 10526 | BINLOG_FORMAT = STATEMENT and at least one table uses a storage | ||
| 10527 | engine limited to row-logging. | ||
| 10528 | |||
| 10529 | 6. Error: Cannot execute row injection: binlogging impossible since | ||
| 10530 | BINLOG_FORMAT = STATEMENT. | ||
| 10531 | |||
| 10532 | 7. Warning: Unsafe statement binlogged in statement format since | ||
| 10533 | BINLOG_FORMAT = STATEMENT. | ||
| 10534 | |||
| 10535 | In addition, we can produce the following error (not depending on | ||
| 10536 | the variables of the decision diagram): | ||
| 10537 | |||
| 10538 | 8. Error: Cannot execute statement: binlogging impossible since more | ||
| 10539 | than one engine is involved and at least one engine is | ||
| 10540 | self-logging. | ||
| 10541 | |||
| 10542 | 9. Error: Do not allow users to modify a gtid_executed table | ||
| 10543 | explicitly by a XA transaction. | ||
| 10544 | |||
| 10545 | For each error case above, the statement is prevented from being | ||
| 10546 | logged, we report an error, and roll back the statement. For | ||
| 10547 | warnings, we set the thd->binlog_flags variable: the warning will be | ||
| 10548 | printed only if the statement is successfully logged. | ||
| 10549 | |||
| 10550 | @see THD::binlog_query | ||
| 10551 | |||
| 10552 | @param[in] tables Tables involved in the query | ||
| 10553 | |||
| 10554 | @retval 0 No error; statement can be logged. | ||
| 10555 | @retval -1 One of the error conditions above applies (1, 2, 4, 5, 6 or 9). | ||
| 10556 | */ | ||
| 10557 | |||
| 10558 | 30388334 | int THD::decide_logging_format(TABLE_LIST *tables) { | |
| 10559 |
1/2✓ Branch 0 taken 30390510 times.
✗ Branch 1 not taken.
|
30388334 | DBUG_TRACE; |
| 10560 |
6/10✓ Branch 0 taken 30389471 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30390193 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 163 times.
✓ Branch 5 taken 30390030 times.
✓ Branch 6 taken 163 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 163 times.
✗ Branch 9 not taken.
|
30390510 | DBUG_PRINT("info", ("query: %s", query().str)); |
| 10561 |
5/8✓ Branch 0 taken 30389831 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30390002 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 163 times.
✓ Branch 5 taken 30389839 times.
✓ Branch 6 taken 163 times.
✗ Branch 7 not taken.
|
30390193 | DBUG_PRINT("info", ("variables.binlog_format: %lu", variables.binlog_format)); |
| 10562 |
6/10✓ Branch 0 taken 30389463 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30389980 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 163 times.
✓ Branch 5 taken 30389817 times.
✓ Branch 6 taken 163 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 163 times.
✗ Branch 9 not taken.
|
30390002 | DBUG_PRINT("info", ("lex->get_stmt_unsafe_flags(): 0x%x", |
| 10563 | lex->get_stmt_unsafe_flags())); | ||
| 10564 | |||
| 10565 | #if defined(ENABLED_DEBUG_SYNC) | ||
| 10566 |
3/4✓ Branch 0 taken 30389418 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30348556 times.
✓ Branch 3 taken 40862 times.
|
30389980 | if (!is_attachable_ro_transaction_active()) |
| 10567 |
3/4✓ Branch 0 taken 28329582 times.
✓ Branch 1 taken 2018494 times.
✓ Branch 2 taken 28331103 times.
✗ Branch 3 not taken.
|
30348556 | DEBUG_SYNC(this, "begin_decide_logging_format"); |
| 10568 | #endif | ||
| 10569 | |||
| 10570 | 30390459 | reset_binlog_local_stmt_filter(); | |
| 10571 | |||
| 10572 | /* | ||
| 10573 | We should not decide logging format if the binlog is closed or | ||
| 10574 | binlogging is off, or if the statement is filtered out from the | ||
| 10575 | binlog by filtering rules. | ||
| 10576 | */ | ||
| 10577 | #ifdef WITH_WSREP | ||
| 10578 |
12/14✓ Branch 0 taken 30390213 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3160071 times.
✓ Branch 3 taken 27230142 times.
✓ Branch 4 taken 512059 times.
✓ Branch 5 taken 2648012 times.
✓ Branch 6 taken 464758 times.
✓ Branch 7 taken 47301 times.
✓ Branch 8 taken 464709 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 314642 times.
✓ Branch 11 taken 150067 times.
✓ Branch 12 taken 858 times.
✓ Branch 13 taken 30389289 times.
|
30704838 | if (WSREP(this) && wsrep_thd_is_local(this) && |
| 10579 |
2/2✓ Branch 0 taken 858 times.
✓ Branch 1 taken 313784 times.
|
314642 | variables.wsrep_trx_fragment_size > 0) { |
| 10580 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 858 times.
|
858 | if (!is_current_stmt_binlog_format_row()) { |
| 10581 | ✗ | my_message(ER_NOT_SUPPORTED_YET, | |
| 10582 | "Streaming replication not supported with " | ||
| 10583 | "binlog_format=STATEMENT", | ||
| 10584 | MYF(0)); | ||
| 10585 | ✗ | return -1; | |
| 10586 | } | ||
| 10587 | } | ||
| 10588 | |||
| 10589 |
8/8✓ Branch 0 taken 512014 times.
✓ Branch 1 taken 2648003 times.
✓ Branch 2 taken 464724 times.
✓ Branch 3 taken 47290 times.
✓ Branch 4 taken 461198 times.
✓ Branch 5 taken 3526 times.
✓ Branch 6 taken 25746629 times.
✓ Branch 7 taken 4639887 times.
|
33546533 | if ((WSREP_EMULATE_BINLOG_NNULL(this) || |
| 10590 |
6/6✓ Branch 0 taken 3160017 times.
✓ Branch 1 taken 27230130 times.
✓ Branch 2 taken 23474082 times.
✓ Branch 3 taken 2272547 times.
✓ Branch 4 taken 23475431 times.
✓ Branch 5 taken 6914629 times.
|
87410780 | (mysql_bin_log.is_open() && (variables.option_bits & OPTION_BIN_LOG))) && |
| 10591 |
2/2✓ Branch 0 taken 2058204 times.
✓ Branch 1 taken 21419404 times.
|
23477608 | !(variables.binlog_format == BINLOG_FORMAT_STMT && |
| 10592 |
3/4✓ Branch 0 taken 2058222 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2056101 times.
✓ Branch 3 taken 2121 times.
|
2058204 | !binlog_filter->db_ok(m_db.str))) { |
| 10593 | #else | ||
| 10594 | if (mysql_bin_log.is_open() && (variables.option_bits & OPTION_BIN_LOG) && | ||
| 10595 | !(variables.binlog_format == BINLOG_FORMAT_STMT && | ||
| 10596 | !binlog_filter->db_ok(m_db.str))) { | ||
| 10597 | #endif /* WITH_WSREP */ | ||
| 10598 | /* | ||
| 10599 | Compute one bit field with the union of all the engine | ||
| 10600 | capabilities, and one with the intersection of all the engine | ||
| 10601 | capabilities. | ||
| 10602 | */ | ||
| 10603 | 23475431 | handler::Table_flags flags_write_some_set = 0; | |
| 10604 | 23475431 | handler::Table_flags flags_access_some_set = 0; | |
| 10605 | 23475431 | handler::Table_flags flags_write_all_set = | |
| 10606 | HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE; | ||
| 10607 | |||
| 10608 | /* | ||
| 10609 | If different types of engines are about to be updated. | ||
| 10610 | For example: Innodb and Falcon; Innodb and MyIsam. | ||
| 10611 | */ | ||
| 10612 | 23475431 | bool multi_write_engine = false; | |
| 10613 | /* | ||
| 10614 | If different types of engines are about to be accessed | ||
| 10615 | and any of them is about to be updated. For example: | ||
| 10616 | Innodb and Falcon; Innodb and MyIsam. | ||
| 10617 | */ | ||
| 10618 | 23475431 | bool multi_access_engine = false; | |
| 10619 | /* | ||
| 10620 | Track if statement creates or drops a temporary table | ||
| 10621 | and log in ROW if it does. | ||
| 10622 | */ | ||
| 10623 | 23475431 | bool is_create_drop_temp_table = false; | |
| 10624 | /* | ||
| 10625 | Identifies if a table is changed. | ||
| 10626 | */ | ||
| 10627 | 23475431 | bool is_write = false; | |
| 10628 | /* | ||
| 10629 | A pointer to a previous table that was changed. | ||
| 10630 | */ | ||
| 10631 | 23475431 | TABLE *prev_write_table = nullptr; | |
| 10632 | /* | ||
| 10633 | A pointer to a previous table that was accessed. | ||
| 10634 | */ | ||
| 10635 | 23475431 | TABLE *prev_access_table = nullptr; | |
| 10636 | /* | ||
| 10637 | True if at least one table is transactional. | ||
| 10638 | */ | ||
| 10639 | 23475431 | bool write_to_some_transactional_table = false; | |
| 10640 | /* | ||
| 10641 | True if at least one table is non-transactional. | ||
| 10642 | */ | ||
| 10643 | 23475431 | bool write_to_some_non_transactional_table = false; | |
| 10644 | /* | ||
| 10645 | True if all non-transactional tables that has been updated | ||
| 10646 | are temporary. | ||
| 10647 | */ | ||
| 10648 | 23475431 | bool write_all_non_transactional_are_tmp_tables = true; | |
| 10649 | /** | ||
| 10650 | The number of tables used in the current statement, | ||
| 10651 | that should be replicated. | ||
| 10652 | */ | ||
| 10653 | 23475431 | uint replicated_tables_count = 0; | |
| 10654 | /** | ||
| 10655 | The number of tables written to in the current statement, | ||
| 10656 | that should not be replicated. | ||
| 10657 | A table should not be replicated when it is considered | ||
| 10658 | 'local' to a MySQL instance. | ||
| 10659 | Currently, these tables are: | ||
| 10660 | - mysql.slow_log | ||
| 10661 | - mysql.general_log | ||
| 10662 | - mysql.slave_relay_log_info | ||
| 10663 | - mysql.slave_master_info | ||
| 10664 | - mysql.slave_worker_info | ||
| 10665 | - performance_schema.* | ||
| 10666 | - TODO: information_schema.* | ||
| 10667 | In practice, from this list, only performance_schema.* tables | ||
| 10668 | are written to by user queries. | ||
| 10669 | */ | ||
| 10670 | 23475431 | uint non_replicated_tables_count = 0; | |
| 10671 | /** | ||
| 10672 | Indicate whether we already reported a warning | ||
| 10673 | on modifying gtid_executed table. | ||
| 10674 | */ | ||
| 10675 | 23475431 | int warned_gtid_executed_table = 0; | |
| 10676 | #ifndef NDEBUG | ||
| 10677 | { | ||
| 10678 |
6/10✓ Branch 0 taken 23475239 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23475288 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 156 times.
✓ Branch 5 taken 23475132 times.
✓ Branch 6 taken 156 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 156 times.
✗ Branch 9 not taken.
|
23475431 | DBUG_PRINT("debug", ("prelocked_mode: %s", |
| 10679 | get_locked_tables_mode_name(locked_tables_mode))); | ||
| 10680 | } | ||
| 10681 | #endif | ||
| 10682 | |||
| 10683 |
4/4✓ Branch 0 taken 3960513 times.
✓ Branch 1 taken 19514775 times.
✓ Branch 2 taken 919501 times.
✓ Branch 3 taken 3041012 times.
|
23475288 | if (variables.binlog_format != BINLOG_FORMAT_ROW && tables) { |
| 10684 | /* | ||
| 10685 | DML statements that modify a table with an auto_increment column based | ||
| 10686 | on rows selected from a table are unsafe as the order in which the rows | ||
| 10687 | are fetched from the select tables cannot be determined and may differ | ||
| 10688 | on master and slave. | ||
| 10689 | */ | ||
| 10690 |
2/2✓ Branch 0 taken 418 times.
✓ Branch 1 taken 919193 times.
|
919501 | if (has_write_table_with_auto_increment_and_query_block(tables)) |
| 10691 |
1/2✓ Branch 0 taken 418 times.
✗ Branch 1 not taken.
|
418 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_WRITE_AUTOINC_SELECT); |
| 10692 | |||
| 10693 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 919571 times.
|
919611 | if (has_write_table_auto_increment_not_first_in_pk(tables)) |
| 10694 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_AUTOINC_NOT_FIRST); |
| 10695 | |||
| 10696 | /* | ||
| 10697 | A query that modifies autoinc column in sub-statement can make the | ||
| 10698 | master and slave inconsistent. | ||
| 10699 | We can solve these problems in mixed mode by switching to binlogging | ||
| 10700 | if at least one updated table is used by sub-statement | ||
| 10701 | */ | ||
| 10702 |
6/6✓ Branch 0 taken 9434 times.
✓ Branch 1 taken 910148 times.
✓ Branch 2 taken 325 times.
✓ Branch 3 taken 9100 times.
✓ Branch 4 taken 325 times.
✓ Branch 5 taken 919248 times.
|
929008 | if (lex->requires_prelocking() && |
| 10703 | 9434 | has_write_table_with_auto_increment(lex->first_not_own_table())) | |
| 10704 |
1/2✓ Branch 0 taken 325 times.
✗ Branch 1 not taken.
|
325 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_AUTOINC_COLUMNS); |
| 10705 | |||
| 10706 | /* | ||
| 10707 | A query that modifies a table with a non-deterministic column default | ||
| 10708 | expression in a substatement, can make the master and the slave | ||
| 10709 | inconsistent. Switch to row logging in mixed mode, and raise a warning | ||
| 10710 | in statement mode. | ||
| 10711 | */ | ||
| 10712 |
4/4✓ Branch 0 taken 9434 times.
✓ Branch 1 taken 910075 times.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 919393 times.
|
928904 | if (lex->requires_prelocking() && |
| 10713 |
3/4✓ Branch 0 taken 9331 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 9318 times.
|
9434 | has_write_table_with_nondeterministic_default( |
| 10714 | 9434 | lex->first_not_own_table())) | |
| 10715 |
1/2✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
|
13 | lex->set_stmt_unsafe( |
| 10716 | LEX::BINLOG_STMT_UNSAFE_DEFAULT_EXPRESSION_IN_SUBSTATEMENT); | ||
| 10717 | |||
| 10718 | /* | ||
| 10719 | A DML or DDL statement is unsafe if it reads a ACL table while | ||
| 10720 | modifying the table, because SE skips acquiring row locks. | ||
| 10721 | Therefore rows seen by DML or DDL may not have same effect on slave. | ||
| 10722 | |||
| 10723 | We skip checking the same under lock tables mode, because we do | ||
| 10724 | not skip row locks on ACL table in this mode. | ||
| 10725 | */ | ||
| 10726 |
3/4✓ Branch 0 taken 919553 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 868 times.
✓ Branch 3 taken 918685 times.
|
919406 | if (has_acl_table_read(this, tables)) { |
| 10727 |
1/2✓ Branch 0 taken 197 times.
✗ Branch 1 not taken.
|
868 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_ACL_TABLE_READ_IN_DML_DDL); |
| 10728 | } | ||
| 10729 | } | ||
| 10730 | |||
| 10731 | /* | ||
| 10732 | Get the capabilities vector for all involved storage engines and | ||
| 10733 | mask out the flags for the binary log. | ||
| 10734 | */ | ||
| 10735 |
2/2✓ Branch 0 taken 10917874 times.
✓ Branch 1 taken 23475947 times.
|
34393821 | for (TABLE_LIST *table = tables; table; table = table->next_global) { |
| 10736 |
2/2✓ Branch 0 taken 1056460 times.
✓ Branch 1 taken 9862338 times.
|
10917874 | if (table->is_placeholder()) { |
| 10737 | /* | ||
| 10738 | Detect if this is a CREATE TEMPORARY or DROP of a | ||
| 10739 | temporary table. This will be used later in determining whether to | ||
| 10740 | log in ROW or STMT if MIXED replication is being used. | ||
| 10741 | */ | ||
| 10742 |
6/6✓ Branch 0 taken 1056457 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 745085 times.
✓ Branch 3 taken 311372 times.
✓ Branch 4 taken 8209 times.
✓ Branch 5 taken 1048251 times.
|
1801545 | if (!is_create_drop_temp_table && !table->table && |
| 10743 |
2/2✓ Branch 0 taken 130388 times.
✓ Branch 1 taken 614697 times.
|
745085 | ((lex->sql_command == SQLCOM_CREATE_TABLE && |
| 10744 |
2/2✓ Branch 0 taken 122179 times.
✓ Branch 1 taken 8209 times.
|
130388 | (lex->create_info->options & HA_LEX_CREATE_TMP_TABLE)) || |
| 10745 |
2/2✓ Branch 0 taken 599821 times.
✓ Branch 1 taken 137055 times.
|
736876 | ((lex->sql_command == SQLCOM_DROP_TABLE || |
| 10746 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 599820 times.
|
599821 | lex->sql_command == SQLCOM_TRUNCATE) && |
| 10747 |
2/4✓ Branch 0 taken 137056 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 137056 times.
|
137056 | find_temporary_table(this, table)))) { |
| 10748 | 8209 | is_create_drop_temp_table = true; | |
| 10749 | } | ||
| 10750 | 1056460 | continue; | |
| 10751 | } | ||
| 10752 | 9862338 | handler::Table_flags const flags = table->table->file->ha_table_flags(); | |
| 10753 | |||
| 10754 |
5/8✓ Branch 0 taken 9861752 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9862044 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 382 times.
✓ Branch 5 taken 9861662 times.
✓ Branch 6 taken 382 times.
✗ Branch 7 not taken.
|
9861299 | DBUG_PRINT("info", ("table: %s; ha_table_flags: 0x%llx", |
| 10755 | table->table_name, flags)); | ||
| 10756 | |||
| 10757 |
2/2✓ Branch 0 taken 886550 times.
✓ Branch 1 taken 8975494 times.
|
9862044 | if (table->table->no_replicate) { |
| 10758 |
1/2✓ Branch 0 taken 886550 times.
✗ Branch 1 not taken.
|
886550 | if (!warned_gtid_executed_table) { |
| 10759 | warned_gtid_executed_table = | ||
| 10760 |
1/2✓ Branch 0 taken 886550 times.
✗ Branch 1 not taken.
|
886550 | gtid_state->warn_or_err_on_modify_gtid_table(this, table); |
| 10761 | /* | ||
| 10762 | Do not allow users to modify the gtid_executed table | ||
| 10763 | explicitly by a XA transaction. | ||
| 10764 | */ | ||
| 10765 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 886547 times.
|
886550 | if (warned_gtid_executed_table == 2) return -1; |
| 10766 | } | ||
| 10767 | /* | ||
| 10768 | The statement uses a table that is not replicated. | ||
| 10769 | The following properties about the table: | ||
| 10770 | - persistent / transient | ||
| 10771 | - transactional / non transactional | ||
| 10772 | - temporary / permanent | ||
| 10773 | - read or write | ||
| 10774 | - multiple engines involved because of this table | ||
| 10775 | are not relevant, as this table is completely ignored. | ||
| 10776 | Because the statement uses a non replicated table, | ||
| 10777 | using STATEMENT format in the binlog is impossible. | ||
| 10778 | Either this statement will be discarded entirely, | ||
| 10779 | or it will be logged (possibly partially) in ROW format. | ||
| 10780 | */ | ||
| 10781 |
1/2✓ Branch 0 taken 886547 times.
✗ Branch 1 not taken.
|
886547 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_TABLE); |
| 10782 | |||
| 10783 |
2/2✓ Branch 0 taken 7925 times.
✓ Branch 1 taken 878622 times.
|
886547 | if (table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE) { |
| 10784 | 7925 | non_replicated_tables_count++; | |
| 10785 | 7925 | continue; | |
| 10786 | } | ||
| 10787 | } | ||
| 10788 | |||
| 10789 | 9854116 | replicated_tables_count++; | |
| 10790 | |||
| 10791 | 9854116 | bool trans = table->table->file->has_transactions(); | |
| 10792 | |||
| 10793 |
2/2✓ Branch 0 taken 5061088 times.
✓ Branch 1 taken 4793231 times.
|
9854329 | if (table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE) { |
| 10794 | 5061088 | write_to_some_transactional_table = | |
| 10795 |
4/4✓ Branch 0 taken 4734014 times.
✓ Branch 1 taken 327074 times.
✓ Branch 2 taken 4316467 times.
✓ Branch 3 taken 417547 times.
|
5061088 | write_to_some_transactional_table || trans; |
| 10796 | |||
| 10797 | 5061088 | write_to_some_non_transactional_table = | |
| 10798 |
4/4✓ Branch 0 taken 5049650 times.
✓ Branch 1 taken 11438 times.
✓ Branch 2 taken 413040 times.
✓ Branch 3 taken 4636610 times.
|
5061088 | write_to_some_non_transactional_table || !trans; |
| 10799 | |||
| 10800 |
2/2✓ Branch 0 taken 337866 times.
✓ Branch 1 taken 4723222 times.
|
5061088 | if (prev_write_table && |
| 10801 |
2/2✓ Branch 0 taken 7771 times.
✓ Branch 1 taken 330095 times.
|
337866 | prev_write_table->file->ht != table->table->file->ht) |
| 10802 | 7771 | multi_write_engine = true; | |
| 10803 | |||
| 10804 |
2/2✓ Branch 0 taken 97133 times.
✓ Branch 1 taken 4963955 times.
|
5061088 | if (table->table->s->tmp_table) |
| 10805 |
3/4✓ Branch 0 taken 95669 times.
✓ Branch 1 taken 1464 times.
✓ Branch 2 taken 97136 times.
✗ Branch 3 not taken.
|
97133 | lex->set_stmt_accessed_table( |
| 10806 | trans ? LEX::STMT_WRITES_TEMP_TRANS_TABLE | ||
| 10807 | : LEX::STMT_WRITES_TEMP_NON_TRANS_TABLE); | ||
| 10808 | else | ||
| 10809 |
3/4✓ Branch 0 taken 4546127 times.
✓ Branch 1 taken 417828 times.
✓ Branch 2 taken 4964296 times.
✗ Branch 3 not taken.
|
4963955 | lex->set_stmt_accessed_table(trans |
| 10810 | ? LEX::STMT_WRITES_TRANS_TABLE | ||
| 10811 | : LEX::STMT_WRITES_NON_TRANS_TABLE); | ||
| 10812 | |||
| 10813 | /* | ||
| 10814 | Non-transactional updates are allowed when row binlog format is | ||
| 10815 | used and all non-transactional tables are temporary. | ||
| 10816 | Binlog format is checked on THD::is_dml_gtid_compatible() method. | ||
| 10817 | */ | ||
| 10818 |
2/2✓ Branch 0 taken 418974 times.
✓ Branch 1 taken 4642458 times.
|
5061432 | if (!trans) |
| 10819 | 418974 | write_all_non_transactional_are_tmp_tables = | |
| 10820 |
2/2✓ Branch 0 taken 413307 times.
✓ Branch 1 taken 5667 times.
|
832281 | write_all_non_transactional_are_tmp_tables && |
| 10821 |
2/2✓ Branch 0 taken 1461 times.
✓ Branch 1 taken 411846 times.
|
413307 | table->table->s->tmp_table; |
| 10822 | |||
| 10823 | 5061432 | flags_write_all_set &= flags; | |
| 10824 | 5061432 | flags_write_some_set |= flags; | |
| 10825 | 5061432 | is_write = true; | |
| 10826 | |||
| 10827 | 5061432 | prev_write_table = table->table; | |
| 10828 | |||
| 10829 | /* | ||
| 10830 | It should be marked unsafe if a table which uses a fulltext parser | ||
| 10831 | plugin is modified. See also bug#48183. | ||
| 10832 | */ | ||
| 10833 |
1/2✓ Branch 0 taken 5060257 times.
✗ Branch 1 not taken.
|
5061432 | if (!lex->is_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_FULLTEXT_PLUGIN)) { |
| 10834 |
2/2✓ Branch 0 taken 169 times.
✓ Branch 1 taken 5060647 times.
|
5060257 | if (fulltext_unsafe_set(table->table->s)) |
| 10835 |
1/2✓ Branch 0 taken 169 times.
✗ Branch 1 not taken.
|
169 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_FULLTEXT_PLUGIN); |
| 10836 | } | ||
| 10837 | /* | ||
| 10838 | INSERT...ON DUPLICATE KEY UPDATE on a table with more than one unique | ||
| 10839 | keys can be unsafe. Check for it if the flag is already not marked for | ||
| 10840 | the given statement. | ||
| 10841 | */ | ||
| 10842 | 5060800 | if (!lex->is_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_INSERT_TWO_KEYS) && | |
| 10843 |
5/6✓ Branch 0 taken 5061105 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4129524 times.
✓ Branch 3 taken 931581 times.
✓ Branch 4 taken 73234 times.
✓ Branch 5 taken 4987830 times.
|
9190588 | lex->sql_command == SQLCOM_INSERT && |
| 10844 |
2/2✓ Branch 0 taken 73234 times.
✓ Branch 1 taken 4056290 times.
|
4129524 | lex->duplicates == DUP_UPDATE) { |
| 10845 | 73234 | uint keys = table->table->s->keys, i = 0, unique_keys = 0; | |
| 10846 | 73234 | for (KEY *keyinfo = table->table->s->key_info; | |
| 10847 |
4/4✓ Branch 0 taken 75934 times.
✓ Branch 1 taken 73225 times.
✓ Branch 2 taken 75925 times.
✓ Branch 3 taken 9 times.
|
149159 | i < keys && unique_keys <= 1; i++, keyinfo++) { |
| 10848 |
2/2✓ Branch 0 taken 73355 times.
✓ Branch 1 taken 2570 times.
|
75925 | if (keyinfo->flags & HA_NOSAME) unique_keys++; |
| 10849 | } | ||
| 10850 |
2/2✓ Branch 0 taken 160 times.
✓ Branch 1 taken 73074 times.
|
73234 | if (unique_keys > 1) |
| 10851 |
1/2✓ Branch 0 taken 160 times.
✗ Branch 1 not taken.
|
160 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_INSERT_TWO_KEYS); |
| 10852 | } | ||
| 10853 | } | ||
| 10854 |
2/2✓ Branch 0 taken 2781 times.
✓ Branch 1 taken 9850981 times.
|
9854295 | if (lex->get_using_match()) { |
| 10855 |
2/2✓ Branch 0 taken 1095 times.
✓ Branch 1 taken 1686 times.
|
2781 | if (fulltext_unsafe_set(table->table->s)) |
| 10856 |
1/2✓ Branch 0 taken 1095 times.
✗ Branch 1 not taken.
|
1095 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_FULLTEXT_PLUGIN); |
| 10857 | } | ||
| 10858 | |||
| 10859 | 9853762 | flags_access_some_set |= flags; | |
| 10860 | |||
| 10861 |
4/4✓ Branch 0 taken 28387 times.
✓ Branch 1 taken 9825375 times.
✓ Branch 2 taken 9844374 times.
✓ Branch 3 taken 9388 times.
|
9882149 | if (lex->sql_command != SQLCOM_CREATE_TABLE || |
| 10862 |
1/2✓ Branch 0 taken 28387 times.
✗ Branch 1 not taken.
|
28387 | (lex->sql_command == SQLCOM_CREATE_TABLE && |
| 10863 |
2/2✓ Branch 0 taken 26138 times.
✓ Branch 1 taken 2249 times.
|
28387 | ((lex->create_info->options & HA_LEX_CREATE_TMP_TABLE) || |
| 10864 |
2/2✓ Branch 0 taken 16625 times.
✓ Branch 1 taken 9513 times.
|
26138 | (table->lock_descriptor().type < TL_WRITE_ALLOW_WRITE)))) { |
| 10865 |
2/2✓ Branch 0 taken 111808 times.
✓ Branch 1 taken 9732566 times.
|
9844374 | if (table->table->s->tmp_table) |
| 10866 |
3/4✓ Branch 0 taken 106839 times.
✓ Branch 1 taken 4969 times.
✓ Branch 2 taken 111810 times.
✗ Branch 3 not taken.
|
111808 | lex->set_stmt_accessed_table( |
| 10867 | trans ? LEX::STMT_READS_TEMP_TRANS_TABLE | ||
| 10868 | : LEX::STMT_READS_TEMP_NON_TRANS_TABLE); | ||
| 10869 | else | ||
| 10870 |
3/4✓ Branch 0 taken 8616737 times.
✓ Branch 1 taken 1115829 times.
✓ Branch 2 taken 9733569 times.
✗ Branch 3 not taken.
|
9732566 | lex->set_stmt_accessed_table(trans ? LEX::STMT_READS_TRANS_TABLE |
| 10871 | : LEX::STMT_READS_NON_TRANS_TABLE); | ||
| 10872 | } | ||
| 10873 | |||
| 10874 |
2/2✓ Branch 0 taken 2751229 times.
✓ Branch 1 taken 7103538 times.
|
9854767 | if (prev_access_table && |
| 10875 |
2/2✓ Branch 0 taken 22103 times.
✓ Branch 1 taken 2729126 times.
|
2751229 | prev_access_table->file->ht != table->table->file->ht) |
| 10876 | 22103 | multi_access_engine = true; | |
| 10877 | |||
| 10878 | 9854767 | prev_access_table = table->table; | |
| 10879 | } | ||
| 10880 |
5/6✓ Branch 0 taken 4723585 times.
✓ Branch 1 taken 18752362 times.
✓ Branch 2 taken 406815 times.
✓ Branch 3 taken 4316770 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 406815 times.
|
23475947 | assert(!is_write || write_to_some_transactional_table || |
| 10881 | write_to_some_non_transactional_table); | ||
| 10882 | /* | ||
| 10883 | write_all_non_transactional_are_tmp_tables may be true if any | ||
| 10884 | non-transactional table was not updated, so we fix its value here. | ||
| 10885 | */ | ||
| 10886 | 23475947 | write_all_non_transactional_are_tmp_tables = | |
| 10887 |
4/4✓ Branch 0 taken 23063092 times.
✓ Branch 1 taken 412855 times.
✓ Branch 2 taken 1289 times.
✓ Branch 3 taken 23061803 times.
|
23475947 | write_all_non_transactional_are_tmp_tables && |
| 10888 | write_to_some_non_transactional_table; | ||
| 10889 | |||
| 10890 |
5/8✓ Branch 0 taken 23475125 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23475205 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 160 times.
✓ Branch 5 taken 23475045 times.
✓ Branch 6 taken 160 times.
✗ Branch 7 not taken.
|
23475947 | DBUG_PRINT("info", ("flags_write_all_set: 0x%llx", flags_write_all_set)); |
| 10891 |
5/8✓ Branch 0 taken 23475122 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23475130 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 160 times.
✓ Branch 5 taken 23474970 times.
✓ Branch 6 taken 160 times.
✗ Branch 7 not taken.
|
23475205 | DBUG_PRINT("info", ("flags_write_some_set: 0x%llx", flags_write_some_set)); |
| 10892 |
5/8✓ Branch 0 taken 23475053 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23475141 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 160 times.
✓ Branch 5 taken 23474981 times.
✓ Branch 6 taken 160 times.
✗ Branch 7 not taken.
|
23475130 | DBUG_PRINT("info", |
| 10893 | ("flags_access_some_set: 0x%llx", flags_access_some_set)); | ||
| 10894 |
5/8✓ Branch 0 taken 23474991 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23475124 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 160 times.
✓ Branch 5 taken 23474964 times.
✓ Branch 6 taken 160 times.
✗ Branch 7 not taken.
|
23475141 | DBUG_PRINT("info", ("multi_write_engine: %d", multi_write_engine)); |
| 10895 |
5/8✓ Branch 0 taken 23474936 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23475113 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 160 times.
✓ Branch 5 taken 23474953 times.
✓ Branch 6 taken 29 times.
✗ Branch 7 not taken.
|
23475124 | DBUG_PRINT("info", ("multi_access_engine: %d", multi_access_engine)); |
| 10896 | |||
| 10897 | 23474982 | int error = 0; | |
| 10898 | int unsafe_flags; | ||
| 10899 | |||
| 10900 | /* | ||
| 10901 | With transactional data dictionary, CREATE TABLE runs as one statement | ||
| 10902 | in a multi-statement transaction internally. Revert this for the | ||
| 10903 | purposes of determining mixed statement safety. | ||
| 10904 | */ | ||
| 10905 |
4/4✓ Branch 0 taken 23321396 times.
✓ Branch 1 taken 153586 times.
✓ Branch 2 taken 7907342 times.
✓ Branch 3 taken 15413945 times.
|
46796269 | const bool multi_stmt_trans = lex->sql_command != SQLCOM_CREATE_TABLE && |
| 10906 | 23321396 | in_multi_stmt_transaction_mode(); | |
| 10907 |
1/2✓ Branch 0 taken 23475225 times.
✗ Branch 1 not taken.
|
23474873 | bool trans_table = trans_has_updated_trans_table(this); |
| 10908 | 23475225 | bool binlog_direct = variables.binlog_direct_non_trans_update; | |
| 10909 | |||
| 10910 |
2/2✓ Branch 0 taken 2931 times.
✓ Branch 1 taken 23473051 times.
|
23475982 | if (lex->is_mixed_stmt_unsafe(multi_stmt_trans, binlog_direct, trans_table, |
| 10911 |
1/2✓ Branch 0 taken 23475982 times.
✗ Branch 1 not taken.
|
23475225 | tx_isolation)) |
| 10912 |
1/2✓ Branch 0 taken 2931 times.
✗ Branch 1 not taken.
|
2931 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_MIXED_STATEMENT); |
| 10913 |
8/8✓ Branch 0 taken 7904696 times.
✓ Branch 1 taken 15568355 times.
✓ Branch 2 taken 6991554 times.
✓ Branch 3 taken 913142 times.
✓ Branch 4 taken 6954155 times.
✓ Branch 5 taken 37399 times.
✓ Branch 6 taken 1346 times.
✓ Branch 7 taken 23471705 times.
|
30427206 | else if (multi_stmt_trans && trans_table && !binlog_direct && |
| 10914 |
3/4✓ Branch 0 taken 6954155 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1346 times.
✓ Branch 3 taken 6952809 times.
|
6954155 | lex->stmt_accessed_table(LEX::STMT_WRITES_NON_TRANS_TABLE)) |
| 10915 |
1/2✓ Branch 0 taken 1346 times.
✗ Branch 1 not taken.
|
1346 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_NONTRANS_AFTER_TRANS); |
| 10916 | |||
| 10917 | /* | ||
| 10918 | If more than one engine is involved in the statement and at | ||
| 10919 | least one is doing it's own logging (is *self-logging*), the | ||
| 10920 | statement cannot be logged atomically, so we generate an error | ||
| 10921 | rather than allowing the binlog to become corrupt. | ||
| 10922 | */ | ||
| 10923 |
3/4✓ Branch 0 taken 7634 times.
✓ Branch 1 taken 23468348 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7634 times.
|
23475982 | if (multi_write_engine && (flags_write_some_set & HA_HAS_OWN_BINLOGGING)) |
| 10924 | ✗ | my_error((error = ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE), | |
| 10925 | MYF(0)); | ||
| 10926 |
2/2✓ Branch 0 taken 21115 times.
✓ Branch 1 taken 23454867 times.
|
23475982 | else if (multi_access_engine && |
| 10927 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21115 times.
|
21115 | flags_access_some_set & HA_HAS_OWN_BINLOGGING) |
| 10928 | ✗ | lex->set_stmt_unsafe( | |
| 10929 | LEX::BINLOG_STMT_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE); | ||
| 10930 | |||
| 10931 | /* XA is unsafe for statements */ | ||
| 10932 |
4/4✓ Branch 0 taken 4723133 times.
✓ Branch 1 taken 18751884 times.
✓ Branch 2 taken 1039 times.
✓ Branch 3 taken 23474118 times.
|
28198290 | if (is_write && |
| 10933 |
2/2✓ Branch 0 taken 1039 times.
✓ Branch 1 taken 4722234 times.
|
4723133 | !get_transaction()->xid_state()->has_state(XID_STATE::XA_NOTR)) |
| 10934 |
1/2✓ Branch 0 taken 1039 times.
✗ Branch 1 not taken.
|
1039 | lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_XA); |
| 10935 | |||
| 10936 |
3/4✓ Branch 0 taken 23475322 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6030 times.
✓ Branch 3 taken 23469292 times.
|
23475157 | DBUG_EXECUTE_IF("make_stmt_only_engines", |
| 10937 | { flags_write_all_set = HA_BINLOG_STMT_CAPABLE; };); | ||
| 10938 | |||
| 10939 | /* both statement-only and row-only engines involved */ | ||
| 10940 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 23475322 times.
|
23475322 | if ((flags_write_all_set & |
| 10941 | (HA_BINLOG_STMT_CAPABLE | HA_BINLOG_ROW_CAPABLE)) == 0) { | ||
| 10942 | /* | ||
| 10943 | 1. Error: Binary logging impossible since both row-incapable | ||
| 10944 | engines and statement-incapable engines are involved | ||
| 10945 | */ | ||
| 10946 | ✗ | my_error((error = ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE), MYF(0)); | |
| 10947 | } | ||
| 10948 | /* statement-only engines involved */ | ||
| 10949 |
2/2✓ Branch 0 taken 6036 times.
✓ Branch 1 taken 23469286 times.
|
23475322 | else if ((flags_write_all_set & HA_BINLOG_ROW_CAPABLE) == 0) { |
| 10950 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6036 times.
|
6036 | if (lex->is_stmt_row_injection()) { |
| 10951 | /* | ||
| 10952 | 4. Error: Cannot execute row injection since table uses | ||
| 10953 | storage engine limited to statement-logging | ||
| 10954 | */ | ||
| 10955 | ✗ | my_error((error = ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE), MYF(0)); | |
| 10956 |
4/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6033 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 6033 times.
|
6039 | } else if (variables.binlog_format == BINLOG_FORMAT_ROW && |
| 10957 |
2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
|
3 | sqlcom_can_generate_row_events(this->lex->sql_command)) { |
| 10958 | /* | ||
| 10959 | 2. Error: Cannot modify table that uses a storage engine | ||
| 10960 | limited to statement-logging when BINLOG_FORMAT = ROW | ||
| 10961 | */ | ||
| 10962 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | my_error((error = ER_BINLOG_ROW_MODE_AND_STMT_ENGINE), MYF(0)); |
| 10963 |
4/4✓ Branch 0 taken 581 times.
✓ Branch 1 taken 5452 times.
✓ Branch 2 taken 177 times.
✓ Branch 3 taken 5856 times.
|
6614 | } else if (variables.binlog_format == BINLOG_FORMAT_MIXED && |
| 10964 |
3/4✓ Branch 0 taken 581 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 177 times.
✓ Branch 3 taken 404 times.
|
581 | ((unsafe_flags = lex->get_stmt_unsafe_flags()) != 0)) { |
| 10965 | /* | ||
| 10966 | 3. Error: Cannot execute statement: binlogging of unsafe | ||
| 10967 | statement is impossible when storage engine is limited to | ||
| 10968 | statement-logging and BINLOG_FORMAT = MIXED. | ||
| 10969 | */ | ||
| 10970 |
2/2✓ Branch 0 taken 4602 times.
✓ Branch 1 taken 177 times.
|
4779 | for (int unsafe_type = 0; unsafe_type < LEX::BINLOG_STMT_UNSAFE_COUNT; |
| 10971 | unsafe_type++) | ||
| 10972 |
2/2✓ Branch 0 taken 201 times.
✓ Branch 1 taken 4401 times.
|
4602 | if (unsafe_flags & (1 << unsafe_type)) |
| 10973 |
1/2✓ Branch 0 taken 201 times.
✗ Branch 1 not taken.
|
201 | my_error( |
| 10974 | (error = ER_BINLOG_UNSAFE_AND_STMT_ENGINE), MYF(0), | ||
| 10975 |
1/2✓ Branch 0 taken 201 times.
✗ Branch 1 not taken.
|
201 | ER_THD_NONCONST(current_thd, |
| 10976 |
1/2✓ Branch 0 taken 201 times.
✗ Branch 1 not taken.
|
201 | LEX::binlog_stmt_unsafe_errcode[unsafe_type])); |
| 10977 |
4/4✓ Branch 0 taken 342 times.
✓ Branch 1 taken 5514 times.
✓ Branch 2 taken 188 times.
✓ Branch 3 taken 5668 times.
|
6198 | } else if (is_write && |
| 10978 |
3/4✓ Branch 0 taken 342 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 188 times.
✓ Branch 3 taken 154 times.
|
342 | ((unsafe_flags = lex->get_stmt_unsafe_flags()) != 0)) { |
| 10979 | /* | ||
| 10980 | 7. Warning: Unsafe statement logged as statement due to | ||
| 10981 | binlog_format = STATEMENT | ||
| 10982 | */ | ||
| 10983 | 188 | binlog_unsafe_warning_flags |= unsafe_flags; | |
| 10984 |
3/12✓ Branch 0 taken 188 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 188 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 188 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
188 | DBUG_PRINT("info", ("Scheduling warning to be issued by " |
| 10985 | "binlog_query: '%s'", | ||
| 10986 | ER_THD(current_thd, ER_BINLOG_UNSAFE_STATEMENT))); | ||
| 10987 |
3/8✓ Branch 0 taken 188 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 188 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 188 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
188 | DBUG_PRINT("info", ("binlog_unsafe_warning_flags: 0x%x", |
| 10988 | binlog_unsafe_warning_flags)); | ||
| 10989 | } | ||
| 10990 | /* log in statement format! */ | ||
| 10991 | } | ||
| 10992 | /* no statement-only engines */ | ||
| 10993 | else { | ||
| 10994 | /* binlog_format = STATEMENT */ | ||
| 10995 |
2/2✓ Branch 0 taken 2050662 times.
✓ Branch 1 taken 21418624 times.
|
23469286 | if (variables.binlog_format == BINLOG_FORMAT_STMT) { |
| 10996 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2050671 times.
|
2050662 | if (lex->is_stmt_row_injection()) { |
| 10997 | /* | ||
| 10998 | 6. Error: Cannot execute row injection since | ||
| 10999 | BINLOG_FORMAT = STATEMENT | ||
| 11000 | */ | ||
| 11001 |
0/2✗ Branch 0 not taken.
✗ Branch 1 not taken.
|
6 | my_error((error = ER_BINLOG_ROW_INJECTION_AND_STMT_MODE), MYF(0)); |
| 11002 |
3/4✓ Branch 0 taken 1123 times.
✓ Branch 1 taken 2049548 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2050671 times.
|
2051794 | } else if ((flags_write_all_set & HA_BINLOG_STMT_CAPABLE) == 0 && |
| 11003 |
2/4✓ Branch 0 taken 1123 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1123 times.
|
1123 | sqlcom_can_generate_row_events(this->lex->sql_command)) { |
| 11004 | /* | ||
| 11005 | 5. Error: Cannot modify table that uses a storage engine | ||
| 11006 | limited to row-logging when binlog_format = STATEMENT | ||
| 11007 | */ | ||
| 11008 | #ifdef WITH_WSREP | ||
| 11009 | ✗ | if (!WSREP_NNULL(this) || wsrep_thd_is_local(this)) { | |
| 11010 | ✗ | my_error((error = ER_BINLOG_STMT_MODE_AND_ROW_ENGINE), MYF(0), ""); | |
| 11011 | } | ||
| 11012 | #else | ||
| 11013 | my_error((error = ER_BINLOG_STMT_MODE_AND_ROW_ENGINE), MYF(0), ""); | ||
| 11014 | #endif /* WITH_WSREP */ | ||
| 11015 |
4/4✓ Branch 0 taken 199171 times.
✓ Branch 1 taken 1851500 times.
✓ Branch 2 taken 13068 times.
✓ Branch 3 taken 2037807 times.
|
2250046 | } else if (is_write && |
| 11016 |
3/4✓ Branch 0 taken 199375 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13068 times.
✓ Branch 3 taken 186307 times.
|
199171 | (unsafe_flags = lex->get_stmt_unsafe_flags()) != 0) { |
| 11017 | /* | ||
| 11018 | 7. Warning: Unsafe statement logged as statement due to | ||
| 11019 | binlog_format = STATEMENT | ||
| 11020 | */ | ||
| 11021 | 13068 | binlog_unsafe_warning_flags |= unsafe_flags; | |
| 11022 |
3/12✓ Branch 0 taken 13068 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13068 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 13068 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
13068 | DBUG_PRINT("info", ("Scheduling warning to be issued by " |
| 11023 | "binlog_query: '%s'", | ||
| 11024 | ER_THD(current_thd, ER_BINLOG_UNSAFE_STATEMENT))); | ||
| 11025 |
3/8✓ Branch 0 taken 13068 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13068 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 13068 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
13068 | DBUG_PRINT("info", ("binlog_unsafe_warning_flags: 0x%x", |
| 11026 | binlog_unsafe_warning_flags)); | ||
| 11027 | } | ||
| 11028 | /* log in statement format! */ | ||
| 11029 | } | ||
| 11030 | /* No statement-only engines and binlog_format != STATEMENT. | ||
| 11031 | I.e., nothing prevents us from row logging if needed. */ | ||
| 11032 | else { | ||
| 11033 |
5/6✓ Branch 0 taken 21418657 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19242334 times.
✓ Branch 3 taken 296798 times.
✓ Branch 4 taken 19241996 times.
✓ Branch 5 taken 366 times.
|
60200331 | if (lex->is_stmt_unsafe() || lex->is_stmt_row_injection() || |
| 11034 | 19242334 | lex->is_stmt_unsafe_with_mixed_mode() || | |
| 11035 |
2/2✓ Branch 0 taken 19240826 times.
✓ Branch 1 taken 1170 times.
|
19241996 | (flags_write_all_set & HA_BINLOG_STMT_CAPABLE) == 0 || |
| 11036 |
3/4✓ Branch 0 taken 19241260 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19138016 times.
✓ Branch 3 taken 103244 times.
|
19240826 | lex->stmt_accessed_table(LEX::STMT_READS_TEMP_TRANS_TABLE) || |
| 11037 |
9/10✓ Branch 0 taken 19539345 times.
✓ Branch 1 taken 1879312 times.
✓ Branch 2 taken 19138029 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 19134778 times.
✓ Branch 5 taken 3251 times.
✓ Branch 6 taken 6416 times.
✓ Branch 7 taken 19128362 times.
✓ Branch 8 taken 2290611 times.
✓ Branch 9 taken 19128308 times.
|
40958251 | lex->stmt_accessed_table(LEX::STMT_READS_TEMP_NON_TRANS_TABLE) || |
| 11038 | is_create_drop_temp_table) { | ||
| 11039 | #ifndef NDEBUG | ||
| 11040 |
1/2✓ Branch 0 taken 2290745 times.
✗ Branch 1 not taken.
|
2290611 | int flags = lex->get_stmt_unsafe_flags(); |
| 11041 |
5/8✓ Branch 0 taken 2290705 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2290708 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2290703 times.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
|
2290745 | DBUG_PRINT("info", ("setting row format for unsafe statement")); |
| 11042 |
2/2✓ Branch 0 taken 59551394 times.
✓ Branch 1 taken 2293668 times.
|
61845062 | for (int i = 0; i < Query_tables_list::BINLOG_STMT_UNSAFE_COUNT; |
| 11043 | i++) { | ||
| 11044 |
2/2✓ Branch 0 taken 1909582 times.
✓ Branch 1 taken 57641812 times.
|
59551394 | if (flags & (1 << i)) |
| 11045 |
7/12✓ Branch 0 taken 1909574 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1909574 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 1909569 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 5 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2974 times.
✗ Branch 11 not taken.
|
1909582 | DBUG_PRINT( |
| 11046 | "info", | ||
| 11047 | ("unsafe reason: %s", | ||
| 11048 | ER_THD_NONCONST( | ||
| 11049 | current_thd, | ||
| 11050 | Query_tables_list::binlog_stmt_unsafe_errcode[i]))); | ||
| 11051 | } | ||
| 11052 |
5/8✓ Branch 0 taken 2290685 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2290680 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2290675 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
|
2293668 | DBUG_PRINT("info", |
| 11053 | ("is_row_injection=%d", lex->is_stmt_row_injection())); | ||
| 11054 |
5/8✓ Branch 0 taken 2290680 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2290678 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2290673 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
|
2290680 | DBUG_PRINT("info", ("stmt_capable=%llu", |
| 11055 | (flags_write_all_set & HA_BINLOG_STMT_CAPABLE))); | ||
| 11056 |
5/8✓ Branch 0 taken 2290652 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2290667 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 2290662 times.
✓ Branch 6 taken 5 times.
✗ Branch 7 not taken.
|
2290678 | DBUG_PRINT("info", ("lex->is_stmt_unsafe_with_mixed_mode = %d", |
| 11057 | lex->is_stmt_unsafe_with_mixed_mode())); | ||
| 11058 | #endif | ||
| 11059 | /* log in row format! */ | ||
| 11060 |
1/2✓ Branch 0 taken 2289543 times.
✗ Branch 1 not taken.
|
2290667 | set_current_stmt_binlog_format_row_if_mixed(); |
| 11061 | } | ||
| 11062 | } | ||
| 11063 | } | ||
| 11064 | |||
| 11065 |
2/2✓ Branch 0 taken 7925 times.
✓ Branch 1 taken 23466837 times.
|
23474762 | if (non_replicated_tables_count > 0) { |
| 11066 |
4/4✓ Branch 0 taken 138 times.
✓ Branch 1 taken 7787 times.
✓ Branch 2 taken 118 times.
✓ Branch 3 taken 20 times.
|
7925 | if ((replicated_tables_count == 0) || !is_write) { |
| 11067 |
3/8✓ Branch 0 taken 7905 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7905 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 7905 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
7905 | DBUG_PRINT("info", |
| 11068 | ("decision: no logging, no replicated table affected")); | ||
| 11069 | 7905 | set_binlog_local_stmt_filter(); | |
| 11070 | } else { | ||
| 11071 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 12 times.
|
20 | if (!is_current_stmt_binlog_format_row()) { |
| 11072 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
8 | my_error((error = ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES), MYF(0)); |
| 11073 | } else { | ||
| 11074 | 12 | clear_binlog_local_stmt_filter(); | |
| 11075 | } | ||
| 11076 | } | ||
| 11077 | } else { | ||
| 11078 | 23466837 | clear_binlog_local_stmt_filter(); | |
| 11079 | } | ||
| 11080 | |||
| 11081 |
4/4✓ Branch 0 taken 23474078 times.
✓ Branch 1 taken 233 times.
✓ Branch 2 taken 396 times.
✓ Branch 3 taken 23475516 times.
|
46949990 | if (!error && |
| 11082 |
3/4✓ Branch 0 taken 23475679 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 396 times.
✓ Branch 3 taken 23475283 times.
|
23474078 | !is_dml_gtid_compatible(write_to_some_transactional_table, |
| 11083 | write_to_some_non_transactional_table, | ||
| 11084 | write_all_non_transactional_are_tmp_tables)) | ||
| 11085 | 396 | error = 1; | |
| 11086 | |||
| 11087 |
2/2✓ Branch 0 taken 584 times.
✓ Branch 1 taken 23475328 times.
|
23475912 | if (error) { |
| 11088 |
3/8✓ Branch 0 taken 584 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 584 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 584 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
584 | DBUG_PRINT("info", ("decision: no logging since an error was generated")); |
| 11089 | 584 | return -1; | |
| 11090 | } | ||
| 11091 | |||
| 11092 |
2/2✓ Branch 0 taken 4722801 times.
✓ Branch 1 taken 18752527 times.
|
23475328 | if (is_write && |
| 11093 |
2/2✓ Branch 0 taken 4425895 times.
✓ Branch 1 taken 296906 times.
|
4722801 | lex->sql_command != SQLCOM_END /* rows-event applying by slave */) { |
| 11094 | /* | ||
| 11095 | Master side of DML in the STMT format events parallelization. | ||
| 11096 | All involving table db:s are stored in a abc-ordered name list. | ||
| 11097 | In case the number of databases exceeds MAX_DBS_IN_EVENT_MTS maximum | ||
| 11098 | the list gathering breaks since it won't be sent to the slave. | ||
| 11099 | */ | ||
| 11100 |
2/2✓ Branch 0 taken 4829697 times.
✓ Branch 1 taken 4424298 times.
|
9253995 | for (TABLE_LIST *table = tables; table; table = table->next_global) { |
| 11101 |
2/2✓ Branch 0 taken 12687 times.
✓ Branch 1 taken 4817350 times.
|
4829697 | if (table->is_placeholder()) continue; |
| 11102 | |||
| 11103 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4817350 times.
|
4817350 | assert(table->table); |
| 11104 | |||
| 11105 |
2/2✓ Branch 0 taken 1457 times.
✓ Branch 1 taken 4815102 times.
|
4817350 | if (table->table->s->is_referenced_by_foreign_key()) { |
| 11106 | /* | ||
| 11107 | FK-referenced dbs can't be gathered currently. The following | ||
| 11108 | event will be marked for sequential execution on slave. | ||
| 11109 | */ | ||
| 11110 | 1457 | binlog_accessed_db_names = nullptr; | |
| 11111 |
1/2✓ Branch 0 taken 1457 times.
✗ Branch 1 not taken.
|
1457 | add_to_binlog_accessed_dbs(""); |
| 11112 | 1457 | break; | |
| 11113 | } | ||
| 11114 |
2/2✓ Branch 0 taken 618140 times.
✓ Branch 1 taken 4197229 times.
|
4815102 | if (!is_current_stmt_binlog_format_row()) |
| 11115 |
1/2✓ Branch 0 taken 618184 times.
✗ Branch 1 not taken.
|
618140 | add_to_binlog_accessed_dbs(table->db); |
| 11116 | } | ||
| 11117 | } | ||
| 11118 |
7/10✓ Branch 0 taken 23473765 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23474817 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 160 times.
✓ Branch 5 taken 23474657 times.
✓ Branch 6 taken 126 times.
✓ Branch 7 taken 34 times.
✓ Branch 8 taken 160 times.
✗ Branch 9 not taken.
|
23475188 | DBUG_PRINT("info", |
| 11119 | ("decision: logging in %s format", | ||
| 11120 | is_current_stmt_binlog_format_row() ? "ROW" : "STATEMENT")); | ||
| 11121 | |||
| 11122 |
2/2✓ Branch 0 taken 19514638 times.
✓ Branch 1 taken 3960179 times.
|
23474817 | if (variables.binlog_format == BINLOG_FORMAT_ROW && |
| 11123 |
2/2✓ Branch 0 taken 19373337 times.
✓ Branch 1 taken 141301 times.
|
19514638 | (lex->sql_command == SQLCOM_UPDATE || |
| 11124 |
2/2✓ Branch 0 taken 19371278 times.
✓ Branch 1 taken 2059 times.
|
19373337 | lex->sql_command == SQLCOM_UPDATE_MULTI || |
| 11125 |
2/2✓ Branch 0 taken 19316775 times.
✓ Branch 1 taken 54503 times.
|
19371278 | lex->sql_command == SQLCOM_DELETE || |
| 11126 |
2/2✓ Branch 0 taken 747 times.
✓ Branch 1 taken 19316028 times.
|
19316775 | lex->sql_command == SQLCOM_DELETE_MULTI)) { |
| 11127 | 198610 | String table_names; | |
| 11128 | /* | ||
| 11129 | Generate a warning for UPDATE/DELETE statements that modify a | ||
| 11130 | BLACKHOLE table, as row events are not logged in row format. | ||
| 11131 | */ | ||
| 11132 |
2/2✓ Branch 0 taken 218795 times.
✓ Branch 1 taken 198789 times.
|
417584 | for (TABLE_LIST *table = tables; table; table = table->next_global) { |
| 11133 |
2/2✓ Branch 0 taken 8701 times.
✓ Branch 1 taken 210141 times.
|
218795 | if (table->is_placeholder()) continue; |
| 11134 |
4/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 210137 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 210138 times.
|
210145 | if (table->table->file->ht->db_type == DB_TYPE_BLACKHOLE_DB && |
| 11135 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
|
4 | table->lock_descriptor().type >= TL_WRITE_ALLOW_WRITE) { |
| 11136 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | table_names.append(table->table_name); |
| 11137 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | table_names.append(","); |
| 11138 | } | ||
| 11139 | } | ||
| 11140 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 198681 times.
|
198789 | if (!table_names.is_empty()) { |
| 11141 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
6 | bool is_update = (lex->sql_command == SQLCOM_UPDATE || |
| 11142 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
|
3 | lex->sql_command == SQLCOM_UPDATE_MULTI); |
| 11143 | /* | ||
| 11144 | Replace the last ',' with '.' for table_names | ||
| 11145 | */ | ||
| 11146 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | table_names.replace(table_names.length() - 1, 1, ".", 1); |
| 11147 |
5/8✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
|
3 | push_warning_printf( |
| 11148 | this, Sql_condition::SL_WARNING, WARN_ON_BLOCKHOLE_IN_RBR, | ||
| 11149 | ER_THD(this, WARN_ON_BLOCKHOLE_IN_RBR), | ||
| 11150 | is_update ? "UPDATE" : "DELETE", table_names.c_ptr()); | ||
| 11151 | } | ||
| 11152 | 198684 | } | |
| 11153 | } else { | ||
| 11154 |
5/10✓ Branch 0 taken 6914273 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6914642 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 6914639 times.
✓ Branch 6 taken 3 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
6914629 | DBUG_PRINT( |
| 11155 | "info", | ||
| 11156 | ("decision: no logging since " | ||
| 11157 | "mysql_bin_log.is_open() = %d " | ||
| 11158 | "and (options & OPTION_BIN_LOG) = 0x%llx " | ||
| 11159 | "and binlog_format = %lu " | ||
| 11160 | "and binlog_filter->db_ok(db) = %d", | ||
| 11161 | mysql_bin_log.is_open(), (variables.option_bits & OPTION_BIN_LOG), | ||
| 11162 | variables.binlog_format, binlog_filter->db_ok(m_db.str))); | ||
| 11163 | |||
| 11164 |
2/2✓ Branch 0 taken 6097521 times.
✓ Branch 1 taken 6914745 times.
|
13012266 | for (TABLE_LIST *table = tables; table; table = table->next_global) { |
| 11165 |
6/6✓ Branch 0 taken 5590257 times.
✓ Branch 1 taken 507340 times.
✓ Branch 2 taken 940335 times.
✓ Branch 3 taken 4649922 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 6097656 times.
|
7037916 | if (!table->is_placeholder() && table->table->no_replicate && |
| 11166 |
3/4✓ Branch 0 taken 940395 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 940394 times.
|
940335 | gtid_state->warn_or_err_on_modify_gtid_table(this, table)) |
| 11167 | 1 | break; | |
| 11168 | } | ||
| 11169 | } | ||
| 11170 | |||
| 11171 | #if defined(ENABLED_DEBUG_SYNC) | ||
| 11172 |
3/4✓ Branch 0 taken 30388342 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 30347775 times.
✓ Branch 3 taken 40567 times.
|
30389638 | if (!is_attachable_ro_transaction_active()) |
| 11173 |
3/4✓ Branch 0 taken 28328935 times.
✓ Branch 1 taken 2018468 times.
✓ Branch 2 taken 28330999 times.
✗ Branch 3 not taken.
|
30347775 | DEBUG_SYNC(this, "end_decide_logging_format"); |
| 11174 | #endif | ||
| 11175 | |||
| 11176 | 30390034 | return 0; | |
| 11177 | 30390621 | } | |
| 11178 | |||
| 11179 | /** | ||
| 11180 | Given that a possible violation of gtid consistency has happened, | ||
| 11181 | checks if gtid-inconsistencies are forbidden by the current value of | ||
| 11182 | ENFORCE_GTID_CONSISTENCY and GTID_MODE. If forbidden, generates | ||
| 11183 | error or warning accordingly. | ||
| 11184 | |||
| 11185 | @param thd The thread that has issued the GTID-violating statement. | ||
| 11186 | |||
| 11187 | @param error_code The error code to use, if error or warning is to | ||
| 11188 | be generated. | ||
| 11189 | |||
| 11190 | @param log_error_code The error code to use, if error message is to | ||
| 11191 | be logged. | ||
| 11192 | |||
| 11193 | @retval false Error was generated. | ||
| 11194 | @retval true No error was generated (possibly a warning was generated). | ||
| 11195 | */ | ||
| 11196 | 11985 | static bool handle_gtid_consistency_violation(THD *thd, int error_code, | |
| 11197 | int log_error_code) { | ||
| 11198 |
1/2✓ Branch 0 taken 11985 times.
✗ Branch 1 not taken.
|
11985 | DBUG_TRACE; |
| 11199 | |||
| 11200 | 11985 | enum_gtid_type gtid_next_type = thd->variables.gtid_next.type; | |
| 11201 |
1/2✓ Branch 0 taken 11985 times.
✗ Branch 1 not taken.
|
11985 | global_sid_lock->rdlock(); |
| 11202 | enum_gtid_consistency_mode gtid_consistency_mode = | ||
| 11203 |
1/2✓ Branch 0 taken 11985 times.
✗ Branch 1 not taken.
|
11985 | get_gtid_consistency_mode(); |
| 11204 |
1/2✓ Branch 0 taken 11985 times.
✗ Branch 1 not taken.
|
11985 | auto gtid_mode = global_gtid_mode.get(); |
| 11205 | |||
| 11206 |
7/12✓ Branch 0 taken 11985 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11985 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 11979 times.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
|
11985 | DBUG_PRINT("info", ("gtid_next.type=%d gtid_mode=%s " |
| 11207 | "gtid_consistency_mode=%d error=%d query=%s", | ||
| 11208 | gtid_next_type, Gtid_mode::to_string(gtid_mode), | ||
| 11209 | gtid_consistency_mode, error_code, thd->query().str)); | ||
| 11210 | |||
| 11211 | /* | ||
| 11212 | GTID violations should generate error if: | ||
| 11213 | - GTID_MODE=ON or ON_PERMISSIVE and GTID_NEXT='AUTOMATIC' (since the | ||
| 11214 | transaction is expected to commit using a GTID), or | ||
| 11215 | - GTID_NEXT='UUID:NUMBER' (since the transaction is expected to | ||
| 11216 | commit usinga GTID), or | ||
| 11217 | - ENFORCE_GTID_CONSISTENCY=ON. | ||
| 11218 | */ | ||
| 11219 |
2/2✓ Branch 0 taken 10632 times.
✓ Branch 1 taken 1353 times.
|
11985 | if ((gtid_next_type == AUTOMATIC_GTID && |
| 11220 |
4/4✓ Branch 0 taken 10291 times.
✓ Branch 1 taken 341 times.
✓ Branch 2 taken 11354 times.
✓ Branch 3 taken 290 times.
|
11985 | gtid_mode >= Gtid_mode::ON_PERMISSIVE) || |
| 11221 |
2/2✓ Branch 0 taken 280 times.
✓ Branch 1 taken 11074 times.
|
11354 | gtid_next_type == ASSIGNED_GTID || |
| 11222 | gtid_consistency_mode == GTID_CONSISTENCY_MODE_ON) { | ||
| 11223 |
1/2✓ Branch 0 taken 911 times.
✗ Branch 1 not taken.
|
911 | global_sid_lock->unlock(); |
| 11224 |
1/2✓ Branch 0 taken 911 times.
✗ Branch 1 not taken.
|
911 | my_error(error_code, MYF(0)); |
| 11225 | 911 | return false; | |
| 11226 | } else { | ||
| 11227 | /* | ||
| 11228 | If we are not generating an error, we must increase the counter | ||
| 11229 | of GTID-violating transactions. This will prevent a concurrent | ||
| 11230 | client from executing a SET GTID_MODE or SET | ||
| 11231 | ENFORCE_GTID_CONSISTENCY statement that would be incompatible | ||
| 11232 | with this transaction. | ||
| 11233 | |||
| 11234 | If the transaction had already been accounted as a gtid violating | ||
| 11235 | transaction, then don't increment the counters, just issue the | ||
| 11236 | warning below. This prevents calling | ||
| 11237 | begin_automatic_gtid_violating_transaction or | ||
| 11238 | begin_anonymous_gtid_violating_transaction multiple times for the | ||
| 11239 | same transaction, which would make the counter go out of sync. | ||
| 11240 | */ | ||
| 11241 |
2/2✓ Branch 0 taken 9705 times.
✓ Branch 1 taken 1369 times.
|
11074 | if (!thd->has_gtid_consistency_violation) { |
| 11242 |
2/2✓ Branch 0 taken 8906 times.
✓ Branch 1 taken 799 times.
|
9705 | if (gtid_next_type == AUTOMATIC_GTID) |
| 11243 |
1/2✓ Branch 0 taken 8906 times.
✗ Branch 1 not taken.
|
8906 | gtid_state->begin_automatic_gtid_violating_transaction(); |
| 11244 | else { | ||
| 11245 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 799 times.
|
799 | assert(gtid_next_type == ANONYMOUS_GTID); |
| 11246 |
1/2✓ Branch 0 taken 799 times.
✗ Branch 1 not taken.
|
799 | gtid_state->begin_anonymous_gtid_violating_transaction(); |
| 11247 | } | ||
| 11248 | |||
| 11249 | /* | ||
| 11250 | If a transaction generates multiple GTID violation conditions, | ||
| 11251 | it must still only update the counters once. Hence we use | ||
| 11252 | this per-thread flag to keep track of whether the thread has a | ||
| 11253 | consistency or not. This function must only be called if the | ||
| 11254 | transaction does not already have a GTID violation. | ||
| 11255 | */ | ||
| 11256 | 9705 | thd->has_gtid_consistency_violation = true; | |
| 11257 | } | ||
| 11258 | |||
| 11259 |
1/2✓ Branch 0 taken 11074 times.
✗ Branch 1 not taken.
|
11074 | global_sid_lock->unlock(); |
| 11260 | |||
| 11261 | // Generate warning if ENFORCE_GTID_CONSISTENCY = WARN. | ||
| 11262 |
2/2✓ Branch 0 taken 288 times.
✓ Branch 1 taken 10786 times.
|
11074 | if (gtid_consistency_mode == GTID_CONSISTENCY_MODE_WARN) { |
| 11263 | // Need to print to log so that replication admin knows when users | ||
| 11264 | // have adjusted their workloads. | ||
| 11265 |
8/16✓ Branch 0 taken 288 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 288 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 288 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 288 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 288 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 288 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 288 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 288 times.
✗ Branch 15 not taken.
|
288 | LogErr(WARNING_LEVEL, log_error_code); |
| 11266 | // Need to print to client so that users can adjust their workload. | ||
| 11267 |
2/4✓ Branch 0 taken 288 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 288 times.
✗ Branch 3 not taken.
|
288 | push_warning(thd, Sql_condition::SL_WARNING, error_code, |
| 11268 | ER_THD_NONCONST(thd, error_code)); | ||
| 11269 | } | ||
| 11270 | 11074 | return true; | |
| 11271 | } | ||
| 11272 | 11985 | } | |
| 11273 | |||
| 11274 | 21667527 | bool THD::is_ddl_gtid_compatible() { | |
| 11275 |
1/2✓ Branch 0 taken 21669182 times.
✗ Branch 1 not taken.
|
21667527 | DBUG_TRACE; |
| 11276 | |||
| 11277 | 21669182 | bool is_binlog_open{mysql_bin_log.is_open()}; | |
| 11278 | 21668745 | bool is_binlog_enabled_for_session{(variables.option_bits & OPTION_BIN_LOG) != | |
| 11279 | 0}; | ||
| 11280 |
4/8✓ Branch 0 taken 21668858 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21668959 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 205 times.
✓ Branch 5 taken 21668754 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
21668745 | DBUG_PRINT("info", ("is_binlog_open:%d is_binlog_enabled_for_session:%d", |
| 11281 | is_binlog_open, is_binlog_enabled_for_session)); | ||
| 11282 | // If we are not going to log, then no problem, we can execute any | ||
| 11283 | // statement. | ||
| 11284 |
4/4✓ Branch 0 taken 16953825 times.
✓ Branch 1 taken 4714364 times.
✓ Branch 2 taken 1143387 times.
✓ Branch 3 taken 15810438 times.
|
21668189 | if (!is_binlog_open || !is_binlog_enabled_for_session) return true; |
| 11285 | |||
| 11286 | 15810438 | bool is_create_table{lex->sql_command == SQLCOM_CREATE_TABLE}; | |
| 11287 | 15810438 | bool is_create_temporary_table{false}; | |
| 11288 | 15810438 | bool is_create_table_select{false}; | |
| 11289 | 15810438 | bool is_create_table_atomic{false}; | |
| 11290 |
2/2✓ Branch 0 taken 145063 times.
✓ Branch 1 taken 15665375 times.
|
15810438 | if (is_create_table) { |
| 11291 | // Check this conditionally, since create_info and/or query_block | ||
| 11292 | // may be uninitialized if sql_command!=SQLCOM_CREATE_TABLE. | ||
| 11293 | 145063 | is_create_temporary_table = | |
| 11294 | 145063 | (lex->create_info->options & HA_LEX_CREATE_TMP_TABLE); | |
| 11295 |
2/2✓ Branch 0 taken 135927 times.
✓ Branch 1 taken 9136 times.
|
145063 | if (!is_create_temporary_table) |
| 11296 |
1/2✓ Branch 0 taken 135927 times.
✗ Branch 1 not taken.
|
135927 | is_create_table_select = !lex->query_block->field_list_is_empty(); |
| 11297 | 145063 | is_create_table_atomic = | |
| 11298 |
1/2✓ Branch 0 taken 145063 times.
✗ Branch 1 not taken.
|
145063 | get_default_handlerton(this, lex->create_info->db_type)->flags & |
| 11299 | HTON_SUPPORTS_ATOMIC_DDL; | ||
| 11300 | } | ||
| 11301 | |||
| 11302 | 15810438 | bool is_drop_table{lex->sql_command == SQLCOM_DROP_TABLE}; | |
| 11303 | 15810438 | bool is_drop_temporary_table{false}; | |
| 11304 |
2/2✓ Branch 0 taken 106379 times.
✓ Branch 1 taken 15704059 times.
|
15810438 | if (is_drop_table) is_drop_temporary_table = lex->drop_temporary; |
| 11305 | |||
| 11306 | 15810438 | bool is_in_transaction{in_multi_stmt_transaction_mode()}; | |
| 11307 | |||
| 11308 | 15810162 | bool is_in_sub_statement{in_sub_stmt != 0}; | |
| 11309 | |||
| 11310 | 15810162 | bool is_binlog_format_statement{variables.binlog_format == | |
| 11311 | BINLOG_FORMAT_STMT}; | ||
| 11312 | |||
| 11313 |
5/8✓ Branch 0 taken 15810894 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15810630 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 203 times.
✓ Branch 5 taken 15810427 times.
✓ Branch 6 taken 203 times.
✗ Branch 7 not taken.
|
15810162 | DBUG_PRINT("info", ("is_create_table:%d is_create_temporary_table:%d " |
| 11314 | "is_create_table_select:%d is_create_table_atomic:%d " | ||
| 11315 | "is_drop_table:%d is_drop_temporary_table:%d " | ||
| 11316 | "is_in_transaction:%d is_in_sub_statement:%d " | ||
| 11317 | "is_binlog_format_statement:%d", | ||
| 11318 | is_create_table, is_create_temporary_table, | ||
| 11319 | is_create_table_select, is_create_table_atomic, | ||
| 11320 | is_drop_table, is_drop_temporary_table, is_in_transaction, | ||
| 11321 | is_in_sub_statement, is_binlog_format_statement)); | ||
| 11322 | |||
| 11323 |
3/4✓ Branch 0 taken 10077 times.
✓ Branch 1 taken 15800553 times.
✓ Branch 2 taken 10077 times.
✗ Branch 3 not taken.
|
15810630 | if (is_create_table_select && !is_create_temporary_table && |
| 11324 |
2/2✓ Branch 0 taken 3321 times.
✓ Branch 1 taken 6756 times.
|
10077 | !is_create_table_atomic) { |
| 11325 | /* | ||
| 11326 | CREATE ... SELECT (without TEMPORARY) for engines not supporting | ||
| 11327 | atomic DDL is unsafe because if binlog_format=row it will be | ||
| 11328 | logged as a CREATE TABLE followed by row events, re-executed | ||
| 11329 | non-atomically as two transactions, and then written to the | ||
| 11330 | slave's binary log as two separate transactions with the same | ||
| 11331 | GTID. | ||
| 11332 | */ | ||
| 11333 |
1/2✓ Branch 0 taken 3321 times.
✗ Branch 1 not taken.
|
3321 | return handle_gtid_consistency_violation( |
| 11334 | this, ER_GTID_UNSAFE_CREATE_SELECT, | ||
| 11335 | 3321 | ER_RPL_GTID_UNSAFE_STMT_CREATE_SELECT); | |
| 11336 | } | ||
| 11337 | |||
| 11338 |
6/6✓ Branch 0 taken 15797362 times.
✓ Branch 1 taken 9947 times.
✓ Branch 2 taken 5956 times.
✓ Branch 3 taken 15791406 times.
✓ Branch 4 taken 3822 times.
✓ Branch 5 taken 12081 times.
|
15807309 | if ((is_create_temporary_table || is_drop_temporary_table) && |
| 11339 |
2/2✓ Branch 0 taken 3336 times.
✓ Branch 1 taken 486 times.
|
3822 | is_binlog_format_statement && |
| 11340 |
2/2✓ Branch 0 taken 608 times.
✓ Branch 1 taken 2728 times.
|
3336 | (is_in_transaction || is_in_sub_statement)) { |
| 11341 | /* | ||
| 11342 | When @@session.binlog_format=statement, | ||
| 11343 | [CREATE|DROP] TEMPORARY TABLE is unsafe to execute inside a | ||
| 11344 | transaction or Procedure, because the [CREATE|DROP] statement on | ||
| 11345 | the temporary table will be executed and written into binary log | ||
| 11346 | with a GTID even if the transaction or Procedure is rolled back. | ||
| 11347 | */ | ||
| 11348 |
1/2✓ Branch 0 taken 486 times.
✗ Branch 1 not taken.
|
1094 | return handle_gtid_consistency_violation( |
| 11349 | this, ER_CLIENT_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRX_IN_SBR, | ||
| 11350 | 486 | ER_SERVER_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRX_IN_SBR); | |
| 11351 | } | ||
| 11352 | |||
| 11353 | 15806215 | return true; | |
| 11354 | 21667773 | } | |
| 11355 | |||
| 11356 | 23473875 | bool THD::is_dml_gtid_compatible(bool some_transactional_table, | |
| 11357 | bool some_non_transactional_table, | ||
| 11358 | bool non_transactional_tables_are_tmp) { | ||
| 11359 |
1/2✓ Branch 0 taken 23475669 times.
✗ Branch 1 not taken.
|
23473875 | DBUG_TRACE; |
| 11360 | |||
| 11361 | // If @@session.sql_log_bin has been manually turned off (only | ||
| 11362 | // doable by SUPER), then no problem, we can execute any statement. | ||
| 11363 |
4/4✓ Branch 0 taken 23474620 times.
✓ Branch 1 taken 1049 times.
✓ Branch 2 taken 3205 times.
✓ Branch 3 taken 23472005 times.
|
46949830 | if ((variables.option_bits & OPTION_BIN_LOG) == 0 || |
| 11364 |
2/2✓ Branch 0 taken 2156 times.
✓ Branch 1 taken 23472005 times.
|
23474620 | mysql_bin_log.is_open() == false) |
| 11365 | 3205 | return true; | |
| 11366 | |||
| 11367 | /* | ||
| 11368 | Single non-transactional updates are allowed when not mixed | ||
| 11369 | together with transactional statements within a transaction. | ||
| 11370 | Furthermore, writing to transactional and non-transactional | ||
| 11371 | engines in a single statement is also disallowed. | ||
| 11372 | Multi-statement transactions on non-transactional tables are | ||
| 11373 | split into single-statement transactions when | ||
| 11374 | GTID_NEXT = "AUTOMATIC". | ||
| 11375 | |||
| 11376 | Non-transactional updates are allowed when row binlog format is | ||
| 11377 | used and all non-transactional tables are temporary. | ||
| 11378 | |||
| 11379 | The debug symbol "allow_gtid_unsafe_non_transactional_updates" | ||
| 11380 | disables the error. This is useful because it allows us to run | ||
| 11381 | old tests that were not written with the restrictions of GTIDs in | ||
| 11382 | mind. | ||
| 11383 | */ | ||
| 11384 |
6/10✓ Branch 0 taken 23472084 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23472170 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 160 times.
✓ Branch 5 taken 23472010 times.
✓ Branch 6 taken 160 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 160 times.
✗ Branch 9 not taken.
|
23472005 | DBUG_PRINT("info", ("some_non_transactional_table=%d " |
| 11385 | "some_transactional_table=%d " | ||
| 11386 | "trans_has_updated_trans_table=%d " | ||
| 11387 | "non_transactional_tables_are_tmp=%d " | ||
| 11388 | "is_current_stmt_binlog_format_row=%d", | ||
| 11389 | some_non_transactional_table, some_transactional_table, | ||
| 11390 | trans_has_updated_trans_table(this), | ||
| 11391 | non_transactional_tables_are_tmp, | ||
| 11392 | is_current_stmt_binlog_format_row())); | ||
| 11393 |
2/2✓ Branch 0 taken 406678 times.
✓ Branch 1 taken 6323 times.
|
413001 | if (some_non_transactional_table && |
| 11394 |
3/4✓ Branch 0 taken 406716 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2180 times.
✓ Branch 3 taken 404536 times.
|
406678 | (some_transactional_table || trans_has_updated_trans_table(this)) && |
| 11395 |
3/4✓ Branch 0 taken 568 times.
✓ Branch 1 taken 7935 times.
✓ Branch 2 taken 1235 times.
✗ Branch 3 not taken.
|
9071 | !(non_transactional_tables_are_tmp && |
| 11396 |
4/4✓ Branch 0 taken 413001 times.
✓ Branch 1 taken 23059169 times.
✓ Branch 2 taken 8178 times.
✓ Branch 3 taken 23463038 times.
|
23884785 | is_current_stmt_binlog_format_row()) && |
| 11397 |
2/4✓ Branch 0 taken 8178 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8178 times.
✗ Branch 3 not taken.
|
9170 | !DBUG_EVALUATE_IF("allow_gtid_unsafe_non_transactional_updates", 1, 0)) { |
| 11398 |
1/2✓ Branch 0 taken 8178 times.
✗ Branch 1 not taken.
|
8178 | return handle_gtid_consistency_violation( |
| 11399 | this, ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE, | ||
| 11400 | 8178 | ER_RPL_GTID_UNSAFE_STMT_ON_NON_TRANS_TABLE); | |
| 11401 | } | ||
| 11402 | |||
| 11403 | 23463038 | return true; | |
| 11404 | 23474421 | } | |
| 11405 | |||
| 11406 | /* | ||
| 11407 | Implementation of interface to write rows to the binary log through the | ||
| 11408 | thread. The thread is responsible for writing the rows it has | ||
| 11409 | inserted/updated/deleted. | ||
| 11410 | */ | ||
| 11411 | |||
| 11412 | /* | ||
| 11413 | Template member function for ensuring that there is an rows log | ||
| 11414 | event of the appropriate type before proceeding. | ||
| 11415 | |||
| 11416 | PRE CONDITION: | ||
| 11417 | - Events of type 'RowEventT' have the type code 'type_code'. | ||
| 11418 | |||
| 11419 | POST CONDITION: | ||
| 11420 | If a non-NULL pointer is returned, the pending event for thread 'thd' will | ||
| 11421 | be an event of type 'RowEventT' (which have the type code 'type_code') | ||
| 11422 | will either empty or have enough space to hold 'needed' bytes. In | ||
| 11423 | addition, the columns bitmap will be correct for the row, meaning that | ||
| 11424 | the pending event will be flushed if the columns in the event differ from | ||
| 11425 | the columns suppled to the function. | ||
| 11426 | |||
| 11427 | RETURNS | ||
| 11428 | If no error, a non-NULL pending event (either one which already existed or | ||
| 11429 | the newly created one). | ||
| 11430 | If error, NULL. | ||
| 11431 | */ | ||
| 11432 | |||
| 11433 | template <class RowsEventT> | ||
| 11434 | 95453912 | Rows_log_event *THD::binlog_prepare_pending_rows_event( | |
| 11435 | TABLE *table, uint32 serv_id, size_t needed, bool is_transactional, | ||
| 11436 | const unsigned char *extra_row_info, uint32 source_part_id) { | ||
| 11437 |
1/2✓ Branch 0 taken 47727165 times.
✗ Branch 1 not taken.
|
95453912 | DBUG_TRACE; |
| 11438 | |||
| 11439 |
3/4✓ Branch 0 taken 47727024 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 47727018 times.
|
95454330 | DBUG_EXECUTE_IF("simulate_null_pending_rows_event", { return nullptr; }); |
| 11440 | |||
| 11441 | /* Fetch the type code for the RowsEventT template parameter */ | ||
| 11442 | 95454036 | int const general_type_code = RowsEventT::TYPE_CODE; | |
| 11443 | |||
| 11444 | 95454036 | partition_info *part_info = table->part_info; | |
| 11445 |
1/2✓ Branch 0 taken 47726618 times.
✗ Branch 1 not taken.
|
95454036 | auto part_id = get_rpl_part_id(part_info); |
| 11446 | |||
| 11447 |
1/2✓ Branch 0 taken 47727029 times.
✗ Branch 1 not taken.
|
95453236 | Rows_log_event *pending = binlog_get_pending_rows_event(is_transactional); |
| 11448 | |||
| 11449 |
5/8✓ Branch 0 taken 43488855 times.
✓ Branch 1 taken 4238174 times.
✓ Branch 2 taken 43488777 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 43488777 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 47726907 times.
|
95454058 | if (unlikely(pending && !pending->is_valid())) return nullptr; |
| 11450 | |||
| 11451 | /* | ||
| 11452 | Check if the current event is non-NULL and a write-rows | ||
| 11453 | event. Also check if the table provided is mapped: if it is not, | ||
| 11454 | then we have switched to writing to a new table. | ||
| 11455 | If there is no pending event, we need to create one. If there is a pending | ||
| 11456 | event, but it's not about the same table id, or not of the same type | ||
| 11457 | (between Write, Update and Delete), or not the same affected columns, or | ||
| 11458 | going to be too big, flush this event to disk and create a new pending | ||
| 11459 | event. | ||
| 11460 | |||
| 11461 | We do not need to check that the pending event and the new event | ||
| 11462 | have the same setting for partial json updates, because | ||
| 11463 | partialness of json can only be changed outside transactions. | ||
| 11464 | */ | ||
| 11465 |
3/4✓ Branch 0 taken 43488747 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 43481020 times.
✓ Branch 3 taken 7696 times.
|
173954922 | if (!pending || pending->server_id != serv_id || |
| 11466 | 86977494 | pending->get_table_id() != table->s->table_map_id || | |
| 11467 |
3/4✓ Branch 0 taken 43480874 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 43480317 times.
✓ Branch 3 taken 557 times.
|
86962040 | pending->get_general_type_code() != general_type_code || |
| 11468 |
3/4✓ Branch 0 taken 43480510 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 43250408 times.
✓ Branch 3 taken 230102 times.
|
86960634 | pending->get_data_size() + needed > binlog_row_event_max_size || |
| 11469 |
7/8✓ Branch 0 taken 43488745 times.
✓ Branch 1 taken 4238162 times.
✓ Branch 2 taken 43250149 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 43250128 times.
✓ Branch 5 taken 21 times.
✓ Branch 6 taken 4641438 times.
✓ Branch 7 taken 43085407 times.
|
268931954 | pending->read_write_bitmaps_cmp(table) == false || |
| 11470 |
3/4✓ Branch 0 taken 43250309 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 164884 times.
✓ Branch 3 taken 43085425 times.
|
86500256 | !(pending->m_extra_row_info.compare_extra_row_info( |
| 11471 | extra_row_info, part_id, source_part_id))) { | ||
| 11472 | /* Create a new RowsEventT... */ | ||
| 11473 |
1/2✓ Branch 0 taken 4641641 times.
✗ Branch 1 not taken.
|
9282876 | Rows_log_event *const ev = new RowsEventT( |
| 11474 |
1/2✓ Branch 0 taken 4641580 times.
✗ Branch 1 not taken.
|
9283282 | this, table, table->s->table_map_id, is_transactional, extra_row_info); |
| 11475 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4641581 times.
|
9283160 | if (unlikely(!ev)) return nullptr; |
| 11476 | 9283162 | ev->server_id = serv_id; // I don't like this, it's too easy to forget. | |
| 11477 | /* | ||
| 11478 | flush the pending event and replace it with the newly created | ||
| 11479 | event... | ||
| 11480 | */ | ||
| 11481 |
2/4✓ Branch 0 taken 4641623 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4641594 times.
|
9283162 | if (unlikely(mysql_bin_log.flush_and_set_pending_rows_event( |
| 11482 | this, ev, is_transactional))) { | ||
| 11483 | ✗ | delete ev; | |
| 11484 | 4 | return nullptr; | |
| 11485 | } | ||
| 11486 | |||
| 11487 | 9283188 | return ev; /* This is the new pending event */ | |
| 11488 | } | ||
| 11489 | 86170814 | return pending; /* This is the current pending event */ | |
| 11490 | 95454018 | } | |
| 11491 | |||
| 11492 | /* Declare in unnamed namespace. */ | ||
| 11493 | namespace { | ||
| 11494 | |||
| 11495 | /** | ||
| 11496 | Class to handle temporary allocation of memory for row data. | ||
| 11497 | |||
| 11498 | The responsibilities of the class is to provide memory for | ||
| 11499 | packing one or two rows of packed data (depending on what | ||
| 11500 | constructor is called). | ||
| 11501 | |||
| 11502 | In order to make the allocation more efficient for rows without blobs, | ||
| 11503 | a pointer to the allocated memory is stored in the table structure | ||
| 11504 | for such rows. If memory for a table containing a blob field | ||
| 11505 | is requested, only memory for that is allocated, and subsequently | ||
| 11506 | released when the object is destroyed. | ||
| 11507 | |||
| 11508 | */ | ||
| 11509 | class Row_data_memory { | ||
| 11510 | public: | ||
| 11511 | /** | ||
| 11512 | Build an object to keep track of a block-local piece of memory | ||
| 11513 | for storing a row of data. | ||
| 11514 | |||
| 11515 | @param table | ||
| 11516 | Table where the pre-allocated memory is stored. | ||
| 11517 | |||
| 11518 | @param data | ||
| 11519 | Pointer to the table record. | ||
| 11520 | */ | ||
| 11521 | 43910900 | Row_data_memory(TABLE *table, const uchar *data) : m_memory(nullptr) { | |
| 11522 | #ifndef NDEBUG | ||
| 11523 | 43910900 | m_alloc_checked = false; | |
| 11524 | #endif | ||
| 11525 | 43910900 | allocate_memory(table, max_row_length(table, data)); | |
| 11526 |
1/2✓ Branch 0 taken 43911398 times.
✗ Branch 1 not taken.
|
43911614 | m_ptr[0] = has_memory() ? m_memory : nullptr; |
| 11527 | 43911398 | m_ptr[1] = nullptr; | |
| 11528 | 43911398 | } | |
| 11529 | |||
| 11530 | 3815524 | Row_data_memory(TABLE *table, const uchar *data1, const uchar *data2, | |
| 11531 | ulonglong value_options = 0) | ||
| 11532 | 3815524 | : m_memory(nullptr) { | |
| 11533 | #ifndef NDEBUG | ||
| 11534 | 3815524 | m_alloc_checked = false; | |
| 11535 | #endif | ||
| 11536 | 3815524 | size_t len1 = max_row_length(table, data1); | |
| 11537 | 3815525 | size_t len2 = max_row_length(table, data2, value_options); | |
| 11538 | 3815525 | allocate_memory(table, len1 + len2); | |
| 11539 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815525 | m_ptr[0] = has_memory() ? m_memory : nullptr; |
| 11540 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815525 | m_ptr[1] = has_memory() ? m_memory + len1 : nullptr; |
| 11541 | 3815525 | } | |
| 11542 | |||
| 11543 | 47726897 | ~Row_data_memory() { | |
| 11544 |
3/4✓ Branch 0 taken 47727030 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3078585 times.
✓ Branch 3 taken 44648445 times.
|
47726897 | if (m_memory != nullptr && m_release_memory_on_destruction) |
| 11545 | 3078585 | my_free(m_memory); | |
| 11546 | 47726902 | } | |
| 11547 | |||
| 11548 | /** | ||
| 11549 | Is there memory allocated? | ||
| 11550 | |||
| 11551 | @retval true There is memory allocated | ||
| 11552 | @retval false Memory allocation failed | ||
| 11553 | */ | ||
| 11554 | 99269259 | bool has_memory() const { | |
| 11555 | #ifndef NDEBUG | ||
| 11556 | 99269259 | m_alloc_checked = true; | |
| 11557 | #endif | ||
| 11558 | 99269259 | return m_memory != nullptr; | |
| 11559 | } | ||
| 11560 | |||
| 11561 | 51542474 | uchar *slot(uint s) { | |
| 11562 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 51542474 times.
|
51542474 | assert(s < sizeof(m_ptr) / sizeof(*m_ptr)); |
| 11563 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 51542474 times.
|
51542474 | assert(m_ptr[s] != nullptr); |
| 11564 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 51542474 times.
|
51542474 | assert(m_alloc_checked == true); |
| 11565 | 51542474 | return m_ptr[s]; | |
| 11566 | } | ||
| 11567 | |||
| 11568 | private: | ||
| 11569 | /** | ||
| 11570 | Compute an upper bound on the amount of memory needed. | ||
| 11571 | |||
| 11572 | This may return an over-approximation. | ||
| 11573 | |||
| 11574 | @param table The table | ||
| 11575 | @param data The server's row record. | ||
| 11576 | @param value_options The value of @@global.binlog_row_value_options | ||
| 11577 | */ | ||
| 11578 | 51541798 | size_t max_row_length(TABLE *table, const uchar *data, | |
| 11579 | ulonglong value_options = 0) { | ||
| 11580 | 51541798 | TABLE_SHARE *table_s = table->s; | |
| 11581 |
1/2✓ Branch 0 taken 51542658 times.
✗ Branch 1 not taken.
|
51541798 | Replicated_columns_view fields{table, Replicated_columns_view::OUTBOUND}; |
| 11582 | /* | ||
| 11583 | The server stores rows using "records". A record is a sequence of bytes | ||
| 11584 | which contains values or pointers to values for all fields (columns). The | ||
| 11585 | server uses table_s->reclength bytes for a row record. | ||
| 11586 | |||
| 11587 | The layout of a record is roughly: | ||
| 11588 | |||
| 11589 | - N+1+B bits, packed into CEIL((N+1+B)/8) bytes, where N is the number of | ||
| 11590 | nullable columns in the table, and B is the sum of the number of bits of | ||
| 11591 | all BIT columns. | ||
| 11592 | |||
| 11593 | - A sequence of serialized fields, each corresponding to a non-BIT, | ||
| 11594 | non-NULL column in the table. | ||
| 11595 | |||
| 11596 | For variable-length columns, the first component of the serialized field | ||
| 11597 | is a length, stored using 1, 2, 3, or 4 bytes depending on the maximum | ||
| 11598 | length for the data type. | ||
| 11599 | |||
| 11600 | For most data types, the next component of the serialized field is the | ||
| 11601 | actual data. But for for VARCHAR, VARBINARY, TEXT, BLOB, and JSON, the | ||
| 11602 | next component of the serialized field is a serialized pointer, | ||
| 11603 | i.e. sizeof(pointer) bytes, which point to another memory area where the | ||
| 11604 | actual data is stored. | ||
| 11605 | |||
| 11606 | The layout of a row image in the binary log is roughly: | ||
| 11607 | |||
| 11608 | - If this is an after-image and partial JSON is enabled, 1 byte containing | ||
| 11609 | value_options. If the PARTIAL_JSON bit of value_options is set, this is | ||
| 11610 | followed by P bits (the "partial_bits"), packed into CEIL(P) bytes, | ||
| 11611 | where P is the number of JSON columns in the table. | ||
| 11612 | |||
| 11613 | - M bits (the "null_bits"), packed into CEIL(M) bytes, where M is the | ||
| 11614 | number of columns in the image. | ||
| 11615 | |||
| 11616 | - A sequence of serialized fields, each corresponding to a non-NULL column | ||
| 11617 | in the row image. | ||
| 11618 | |||
| 11619 | For variable-length columns, the first component of the serialized field | ||
| 11620 | is a length, stored using 1, 2, 3, or 4 bytes depending on the maximum | ||
| 11621 | length for the data type. | ||
| 11622 | |||
| 11623 | For most data types, the next component of the serialized field is the | ||
| 11624 | actual field data. But for JSON fields where the corresponding bit of | ||
| 11625 | the partial_bits is 1, this is a sequence of diffs instead. | ||
| 11626 | |||
| 11627 | Now we try to use table_s->reclength to estimate how much memory to | ||
| 11628 | allocate for a row image in the binlog. Due to the differences this will | ||
| 11629 | only be an upper bound. Notice the differences: | ||
| 11630 | |||
| 11631 | - The binlog may only include a subset of the fields (the row image), | ||
| 11632 | whereas reclength contains space for all fields. | ||
| 11633 | |||
| 11634 | - BIT columns are not packed together with NULL bits in the binlog, so up | ||
| 11635 | to 1 more byte per BIT column may be needed. | ||
| 11636 | |||
| 11637 | - The binlog has a null bit even for non-nullable fields, whereas the | ||
| 11638 | reclength only contains space nullable fields, so the binlog may need up | ||
| 11639 | to CEIL(table_s->fields/8) more bytes. | ||
| 11640 | |||
| 11641 | - The binlog only has a null bit for fields in the image, whereas the | ||
| 11642 | reclength contains space for all fields. | ||
| 11643 | |||
| 11644 | - The binlog contains the full blob whereas the record only contains | ||
| 11645 | sizeof(pointer) bytes. | ||
| 11646 | |||
| 11647 | - The binlog contains value_options and partial_bits. So this may use up | ||
| 11648 | to 1+CEIL(table_s->fields/8) more bytes. | ||
| 11649 | |||
| 11650 | - The binlog may contain partial JSON. This is guaranteed to be smaller | ||
| 11651 | than the size of the full value. | ||
| 11652 | |||
| 11653 | - There may exist columns that, due to their nature, are not replicated, | ||
| 11654 | for instance, hidden generated columns used for functional indexes. | ||
| 11655 | |||
| 11656 | For those data types that are not stored using a pointer, the size of the | ||
| 11657 | field in the binary log is at most 2 bytes more than what the field | ||
| 11658 | contributes to in table_s->reclength, because those data types use at most | ||
| 11659 | 1 byte for the length and waste less than a byte on extra padding and | ||
| 11660 | extra bits in null_bits or BIT columns. | ||
| 11661 | |||
| 11662 | For those data types that are stored using a pointer, the size of the | ||
| 11663 | field in the binary log is at most 2 bytes more than what the field | ||
| 11664 | contributes to in table_s->reclength, plus the size of the data. The size | ||
| 11665 | of the pointer is at least 4 on all supported platforms, so it is bigger | ||
| 11666 | than what is used by partial_bits, value_format, or any waste due to extra | ||
| 11667 | padding and extra bits in null_bits. | ||
| 11668 | */ | ||
| 11669 | 51542658 | size_t length = table_s->reclength + 2 * (fields.filtered_size()); | |
| 11670 | |||
| 11671 |
2/2✓ Branch 0 taken 6157011 times.
✓ Branch 1 taken 51542067 times.
|
57699078 | for (uint i = 0; i < table_s->blob_fields; i++) { |
| 11672 |
2/2✓ Branch 0 taken 1288 times.
✓ Branch 1 taken 6155724 times.
|
6157011 | if (fields.is_excluded(table_s->blob_field[i])) continue; |
| 11673 | |||
| 11674 | 6155724 | Field *field = table->field[table_s->blob_field[i]]; | |
| 11675 | 6155724 | Field_blob *field_blob = down_cast<Field_blob *>(field); | |
| 11676 | |||
| 11677 |
5/6✓ Branch 0 taken 6155720 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 193476 times.
✓ Branch 3 taken 5962244 times.
✓ Branch 4 taken 8939 times.
✓ Branch 5 taken 6146781 times.
|
6349151 | if (field_blob->type() == MYSQL_TYPE_JSON && |
| 11678 |
2/2✓ Branch 0 taken 8939 times.
✓ Branch 1 taken 184537 times.
|
193476 | (value_options & PARTIAL_JSON_UPDATES) != 0) { |
| 11679 | 8939 | Field_json *field_json = down_cast<Field_json *>(field_blob); | |
| 11680 |
1/2✓ Branch 0 taken 8939 times.
✗ Branch 1 not taken.
|
8939 | length += field_json->get_diff_vector_and_length(value_options); |
| 11681 | } else | ||
| 11682 | 6146785 | length += | |
| 11683 |
1/2✓ Branch 0 taken 6146785 times.
✗ Branch 1 not taken.
|
6146781 | field_blob->get_length(data + field_blob->offset(table->record[0])); |
| 11684 | } | ||
| 11685 | 51542709 | return length; | |
| 11686 | 51542067 | } | |
| 11687 | |||
| 11688 | 47727054 | void allocate_memory(TABLE *const table, const size_t total_length) { | |
| 11689 |
2/2✓ Branch 0 taken 44648506 times.
✓ Branch 1 taken 3078548 times.
|
47727054 | if (table->s->blob_fields == 0) { |
| 11690 | /* | ||
| 11691 | The maximum length of a packed record is less than this | ||
| 11692 | length. We use this value instead of the supplied length | ||
| 11693 | when allocating memory for records, since we don't know how | ||
| 11694 | the memory will be used in future allocations. | ||
| 11695 | |||
| 11696 | Since table->s->reclength is for unpacked records, we have | ||
| 11697 | to add two bytes for each field, which can potentially be | ||
| 11698 | added to hold the length of a packed field. | ||
| 11699 | */ | ||
| 11700 | 44648506 | size_t const maxlen = table->s->reclength + 2 * table->s->fields; | |
| 11701 | |||
| 11702 | /* | ||
| 11703 | Allocate memory for two records if memory hasn't been | ||
| 11704 | allocated. We allocate memory for two records so that it can | ||
| 11705 | be used when processing update rows as well. | ||
| 11706 | */ | ||
| 11707 |
2/2✓ Branch 0 taken 115520 times.
✓ Branch 1 taken 44532986 times.
|
44648506 | if (table->write_row_record == nullptr) |
| 11708 | 115520 | table->write_row_record = (uchar *)table->mem_root.Alloc(2 * maxlen); | |
| 11709 | 44648507 | m_memory = table->write_row_record; | |
| 11710 | 44648507 | m_release_memory_on_destruction = false; | |
| 11711 | } else { | ||
| 11712 | 3078548 | m_memory = (uchar *)my_malloc(key_memory_Row_data_memory_memory, | |
| 11713 | total_length, MYF(MY_WME)); | ||
| 11714 | 3078590 | m_release_memory_on_destruction = true; | |
| 11715 | } | ||
| 11716 | 47727097 | } | |
| 11717 | |||
| 11718 | #ifndef NDEBUG | ||
| 11719 | mutable bool m_alloc_checked; | ||
| 11720 | #endif | ||
| 11721 | bool m_release_memory_on_destruction; | ||
| 11722 | uchar *m_memory; | ||
| 11723 | uchar *m_ptr[2]; | ||
| 11724 | }; | ||
| 11725 | |||
| 11726 | } // namespace | ||
| 11727 | |||
| 11728 | 41827243 | int THD::binlog_write_row(TABLE *table, bool is_trans, uchar const *record, | |
| 11729 | const unsigned char *extra_row_info) { | ||
| 11730 | #ifdef WITH_WSREP | ||
| 11731 |
11/12✓ Branch 0 taken 41827837 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5430010 times.
✓ Branch 3 taken 36397827 times.
✓ Branch 4 taken 5430008 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 5430005 times.
✓ Branch 7 taken 3 times.
✓ Branch 8 taken 5334944 times.
✓ Branch 9 taken 95061 times.
✓ Branch 10 taken 41732815 times.
✓ Branch 11 taken 18 times.
|
41827243 | assert(is_current_stmt_binlog_format_row() && |
| 11732 | ((WSREP_EMULATE_BINLOG_NNULL(this) || mysql_bin_log.is_open()))); | ||
| 11733 | #else | ||
| 11734 | assert(is_current_stmt_binlog_format_row() && mysql_bin_log.is_open()); | ||
| 11735 | #endif /* WITH_WSREP */ | ||
| 11736 | |||
| 11737 | /* | ||
| 11738 | Pack records into format for transfer. We are allocating more | ||
| 11739 | memory than needed, but that doesn't matter. | ||
| 11740 | */ | ||
| 11741 |
1/2✓ Branch 0 taken 41827768 times.
✗ Branch 1 not taken.
|
41827876 | Row_data_memory memory(table, record); |
| 11742 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 41827808 times.
|
41827768 | if (!memory.has_memory()) return HA_ERR_OUT_OF_MEM; |
| 11743 | |||
| 11744 | 41827808 | uchar *row_data = memory.slot(0); | |
| 11745 | |||
| 11746 |
1/2✓ Branch 0 taken 41827866 times.
✗ Branch 1 not taken.
|
41827819 | size_t const len = pack_row(table, table->write_set, row_data, record, |
| 11747 | enum_row_image_type::WRITE_AI); | ||
| 11748 | |||
| 11749 | Rows_log_event *const ev = | ||
| 11750 |
1/2✓ Branch 0 taken 41827914 times.
✗ Branch 1 not taken.
|
41827866 | binlog_prepare_pending_rows_event<Write_rows_log_event>( |
| 11751 | table, server_id, len, is_trans, extra_row_info); | ||
| 11752 | |||
| 11753 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 41827887 times.
|
41827914 | if (unlikely(ev == nullptr)) return HA_ERR_OUT_OF_MEM; |
| 11754 | |||
| 11755 |
1/2✓ Branch 0 taken 41827946 times.
✗ Branch 1 not taken.
|
41827887 | return ev->add_row_data(row_data, len); |
| 11756 | 41827950 | } | |
| 11757 | |||
| 11758 | 3815524 | int THD::binlog_update_row(TABLE *table, bool is_trans, | |
| 11759 | const uchar *before_record, | ||
| 11760 | const uchar *after_record, | ||
| 11761 | const unsigned char *extra_row_info) { | ||
| 11762 | #ifdef WITH_WSREP | ||
| 11763 |
8/12✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1014157 times.
✓ Branch 3 taken 2801368 times.
✓ Branch 4 taken 1014157 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1014157 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1014141 times.
✓ Branch 9 taken 16 times.
✓ Branch 10 taken 3815509 times.
✗ Branch 11 not taken.
|
3815524 | assert(is_current_stmt_binlog_format_row() && |
| 11764 | ((WSREP_EMULATE_BINLOG_NNULL(this) || mysql_bin_log.is_open()))); | ||
| 11765 | #else | ||
| 11766 | assert(is_current_stmt_binlog_format_row() && mysql_bin_log.is_open()); | ||
| 11767 | #endif /* WITH_WSREP */ | ||
| 11768 | |||
| 11769 | 3815525 | int error = 0; | |
| 11770 | |||
| 11771 | /** | ||
| 11772 | Save a reference to the original read and write set bitmaps. | ||
| 11773 | We will need this to restore the bitmaps at the end. | ||
| 11774 | */ | ||
| 11775 | 3815525 | MY_BITMAP *old_read_set = table->read_set; | |
| 11776 | 3815525 | MY_BITMAP *old_write_set = table->write_set; | |
| 11777 | |||
| 11778 | /** | ||
| 11779 | This will remove spurious fields required during execution but | ||
| 11780 | not needed for binlogging. This is done according to the: | ||
| 11781 | binlog-row-image option. | ||
| 11782 | */ | ||
| 11783 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815525 | binlog_prepare_row_images(this, table); |
| 11784 | |||
| 11785 | Row_data_memory row_data(table, before_record, after_record, | ||
| 11786 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815525 | variables.binlog_row_value_options); |
| 11787 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3815525 times.
|
3815525 | if (!row_data.has_memory()) return HA_ERR_OUT_OF_MEM; |
| 11788 | |||
| 11789 | 3815525 | uchar *before_row = row_data.slot(0); | |
| 11790 | 3815525 | uchar *after_row = row_data.slot(1); | |
| 11791 | |||
| 11792 | size_t const before_size = | ||
| 11793 |
1/2✓ Branch 0 taken 3815523 times.
✗ Branch 1 not taken.
|
3815525 | pack_row(table, table->read_set, before_row, before_record, |
| 11794 | enum_row_image_type::UPDATE_BI); | ||
| 11795 | 7631048 | size_t const after_size = pack_row( | |
| 11796 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815523 | table, table->write_set, after_row, after_record, |
| 11797 | enum_row_image_type::UPDATE_AI, variables.binlog_row_value_options); | ||
| 11798 | |||
| 11799 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815525 | DBUG_DUMP("before_record", before_record, table->s->reclength); |
| 11800 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815525 | DBUG_DUMP("after_record", after_record, table->s->reclength); |
| 11801 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815525 | DBUG_DUMP("before_row", before_row, before_size); |
| 11802 |
1/2✓ Branch 0 taken 3815525 times.
✗ Branch 1 not taken.
|
3815525 | DBUG_DUMP("after_row", after_row, after_size); |
| 11803 | |||
| 11804 | 3815525 | partition_info *part_info = table->part_info; | |
| 11805 | 3815525 | uint32 source_part_id = binary_log::Rows_event::Extra_row_info::UNDEFINED; | |
| 11806 |
2/2✓ Branch 0 taken 116646 times.
✓ Branch 1 taken 3698879 times.
|
3815525 | if (part_info) { |
| 11807 | 116646 | uint32 new_part_id = binary_log::Rows_event::Extra_row_info::UNDEFINED; | |
| 11808 | 116646 | longlong func_value = 0; | |
| 11809 |
1/2✓ Branch 0 taken 116646 times.
✗ Branch 1 not taken.
|
116646 | get_parts_for_update(before_record, after_record, table->record[0], |
| 11810 | part_info, &source_part_id, &new_part_id, &func_value); | ||
| 11811 | } | ||
| 11812 | |||
| 11813 | Rows_log_event *const ev = | ||
| 11814 |
1/2✓ Branch 0 taken 3815523 times.
✗ Branch 1 not taken.
|
3815525 | binlog_prepare_pending_rows_event<Update_rows_log_event>( |
| 11815 | table, server_id, before_size + after_size, is_trans, extra_row_info, | ||
| 11816 | source_part_id); | ||
| 11817 | |||
| 11818 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3815522 times.
|
3815523 | if (unlikely(ev == nullptr)) return HA_ERR_OUT_OF_MEM; |
| 11819 | |||
| 11820 |
2/2✓ Branch 0 taken 116645 times.
✓ Branch 1 taken 3698877 times.
|
3815522 | if (part_info) { |
| 11821 | 116645 | ev->m_extra_row_info.set_source_partition_id(source_part_id); | |
| 11822 | } | ||
| 11823 | |||
| 11824 |
3/4✓ Branch 0 taken 3815523 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3815522 times.
✓ Branch 3 taken 1 times.
|
7631045 | error = ev->add_row_data(before_row, before_size) || |
| 11825 |
2/4✓ Branch 0 taken 3815523 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3815523 times.
|
3815522 | ev->add_row_data(after_row, after_size); |
| 11826 | |||
| 11827 | /* restore read/write set for the rest of execution */ | ||
| 11828 | 3815524 | table->column_bitmaps_set_no_signal(old_read_set, old_write_set); | |
| 11829 | |||
| 11830 | 3815519 | bitmap_clear_all(&table->tmp_set); | |
| 11831 | |||
| 11832 | 3815521 | return error; | |
| 11833 | 3815523 | } | |
| 11834 | |||
| 11835 | 2083635 | int THD::binlog_delete_row(TABLE *table, bool is_trans, uchar const *record, | |
| 11836 | const unsigned char *extra_row_info) { | ||
| 11837 | #ifdef WITH_WSREP | ||
| 11838 |
8/12✓ Branch 0 taken 2083635 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24368 times.
✓ Branch 3 taken 2059267 times.
✓ Branch 4 taken 24368 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 24368 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 24366 times.
✓ Branch 9 taken 2 times.
✓ Branch 10 taken 2083633 times.
✗ Branch 11 not taken.
|
2083635 | assert(is_current_stmt_binlog_format_row() && |
| 11839 | ((WSREP_EMULATE_BINLOG_NNULL(this) || mysql_bin_log.is_open()))); | ||
| 11840 | #else | ||
| 11841 | assert(is_current_stmt_binlog_format_row() && mysql_bin_log.is_open()); | ||
| 11842 | #endif /* WITH_WSREP */ | ||
| 11843 | |||
| 11844 | 2083635 | int error = 0; | |
| 11845 | |||
| 11846 | /** | ||
| 11847 | Save a reference to the original read and write set bitmaps. | ||
| 11848 | We will need this to restore the bitmaps at the end. | ||
| 11849 | */ | ||
| 11850 | 2083635 | MY_BITMAP *old_read_set = table->read_set; | |
| 11851 | 2083635 | MY_BITMAP *old_write_set = table->write_set; | |
| 11852 | |||
| 11853 | /** | ||
| 11854 | This will remove spurious fields required during execution but | ||
| 11855 | not needed for binlogging. This is done according to the: | ||
| 11856 | binlog-row-image option. | ||
| 11857 | */ | ||
| 11858 |
1/2✓ Branch 0 taken 2083635 times.
✗ Branch 1 not taken.
|
2083635 | binlog_prepare_row_images(this, table); |
| 11859 | |||
| 11860 | /* | ||
| 11861 | Pack records into format for transfer. We are allocating more | ||
| 11862 | memory than needed, but that doesn't matter. | ||
| 11863 | */ | ||
| 11864 |
1/2✓ Branch 0 taken 2083635 times.
✗ Branch 1 not taken.
|
2083635 | Row_data_memory memory(table, record); |
| 11865 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2083635 times.
|
2083635 | if (unlikely(!memory.has_memory())) return HA_ERR_OUT_OF_MEM; |
| 11866 | |||
| 11867 | 2083635 | uchar *row_data = memory.slot(0); | |
| 11868 | |||
| 11869 |
1/2✓ Branch 0 taken 2083635 times.
✗ Branch 1 not taken.
|
2083635 | DBUG_DUMP("table->read_set", (uchar *)table->read_set->bitmap, |
| 11870 | (table->s->fields + 7) / 8); | ||
| 11871 |
1/2✓ Branch 0 taken 2083635 times.
✗ Branch 1 not taken.
|
2083635 | size_t const len = pack_row(table, table->read_set, row_data, record, |
| 11872 | enum_row_image_type::DELETE_BI); | ||
| 11873 | |||
| 11874 | Rows_log_event *const ev = | ||
| 11875 |
1/2✓ Branch 0 taken 2083635 times.
✗ Branch 1 not taken.
|
2083635 | binlog_prepare_pending_rows_event<Delete_rows_log_event>( |
| 11876 | table, server_id, len, is_trans, extra_row_info); | ||
| 11877 | |||
| 11878 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2083633 times.
|
2083635 | if (unlikely(ev == nullptr)) return HA_ERR_OUT_OF_MEM; |
| 11879 | |||
| 11880 |
1/2✓ Branch 0 taken 2083633 times.
✗ Branch 1 not taken.
|
2083633 | error = ev->add_row_data(row_data, len); |
| 11881 | |||
| 11882 | /* restore read/write set for the rest of execution */ | ||
| 11883 | 2083633 | table->column_bitmaps_set_no_signal(old_read_set, old_write_set); | |
| 11884 | |||
| 11885 | 2083633 | bitmap_clear_all(&table->tmp_set); | |
| 11886 | 2083633 | return error; | |
| 11887 | 2083635 | } | |
| 11888 | |||
| 11889 | 5899159 | void binlog_prepare_row_images(const THD *thd, TABLE *table) { | |
| 11890 |
1/2✓ Branch 0 taken 5899160 times.
✗ Branch 1 not taken.
|
5899159 | DBUG_TRACE; |
| 11891 | /** | ||
| 11892 | Remove from read_set spurious columns. The write_set has been | ||
| 11893 | handled before in table->mark_columns_needed_for_update. | ||
| 11894 | */ | ||
| 11895 | |||
| 11896 |
9/12✓ Branch 0 taken 22686936 times.
✓ Branch 1 taken 12866 times.
✓ Branch 2 taken 22699801 times.
✓ Branch 3 taken 5899158 times.
✓ Branch 4 taken 5899159 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5899160 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✓ Branch 9 taken 5899151 times.
✓ Branch 10 taken 8 times.
✗ Branch 11 not taken.
|
28598961 | DBUG_PRINT_BITSET("debug", "table->read_set (before preparing): %s", |
| 11897 | table->read_set); | ||
| 11898 | |||
| 11899 | /** | ||
| 11900 | if there is a primary key in the table (ie, user declared PK or a | ||
| 11901 | non-null unique index) and we dont want to ship the entire image, | ||
| 11902 | and the handler involved supports this. | ||
| 11903 | */ | ||
| 11904 | 16060331 | if (table->s->primary_key < MAX_KEY && | |
| 11905 |
6/6✓ Branch 0 taken 4262013 times.
✓ Branch 1 taken 1637146 times.
✓ Branch 2 taken 8655 times.
✓ Branch 3 taken 4253358 times.
✓ Branch 4 taken 8655 times.
✓ Branch 5 taken 5890504 times.
|
5907814 | (thd->variables.binlog_row_image < BINLOG_ROW_IMAGE_FULL) && |
| 11906 |
2/4✓ Branch 0 taken 8655 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8655 times.
✗ Branch 3 not taken.
|
8655 | !ha_check_storage_engine_flag(table->s->db_type(), |
| 11907 | HTON_NO_BINLOG_ROW_OPT)) { | ||
| 11908 | /** | ||
| 11909 | Just to be sure that tmp_set is currently not in use as | ||
| 11910 | the read_set already. | ||
| 11911 | */ | ||
| 11912 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8655 times.
|
8655 | assert(table->read_set != &table->tmp_set); |
| 11913 | // Verify it's not used | ||
| 11914 |
2/4✓ Branch 0 taken 8655 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8655 times.
|
8655 | assert(bitmap_is_clear_all(&table->tmp_set)); |
| 11915 | |||
| 11916 |
2/3✓ Branch 0 taken 5178 times.
✓ Branch 1 taken 3477 times.
✗ Branch 2 not taken.
|
8655 | switch (thd->variables.binlog_row_image) { |
| 11917 | 5178 | case BINLOG_ROW_IMAGE_MINIMAL: | |
| 11918 | /* MINIMAL: Mark only PK */ | ||
| 11919 |
1/2✓ Branch 0 taken 5178 times.
✗ Branch 1 not taken.
|
5178 | table->mark_columns_used_by_index_no_reset(table->s->primary_key, |
| 11920 | &table->tmp_set); | ||
| 11921 | 5178 | break; | |
| 11922 | 3477 | case BINLOG_ROW_IMAGE_NOBLOB: | |
| 11923 | /** | ||
| 11924 | NOBLOB: Remove unnecessary BLOB fields from read_set | ||
| 11925 | (the ones that are not part of PK). | ||
| 11926 | */ | ||
| 11927 |
1/2✓ Branch 0 taken 3477 times.
✗ Branch 1 not taken.
|
3477 | bitmap_union(&table->tmp_set, table->read_set); |
| 11928 |
2/2✓ Branch 0 taken 12966 times.
✓ Branch 1 taken 3477 times.
|
16443 | for (Field **ptr = table->field; *ptr; ptr++) { |
| 11929 | 12966 | Field *field = (*ptr); | |
| 11930 |
5/6✓ Branch 0 taken 12966 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1486 times.
✓ Branch 3 taken 11480 times.
✓ Branch 4 taken 1088 times.
✓ Branch 5 taken 11878 times.
|
14452 | if ((field->type() == MYSQL_TYPE_BLOB) && |
| 11931 |
2/2✓ Branch 0 taken 1088 times.
✓ Branch 1 taken 398 times.
|
1486 | !field->is_flag_set(PRI_KEY_FLAG)) |
| 11932 | 1088 | bitmap_clear_bit(&table->tmp_set, field->field_index()); | |
| 11933 | } | ||
| 11934 | 3477 | break; | |
| 11935 | ✗ | default: | |
| 11936 | ✗ | assert(0); // impossible. | |
| 11937 | } | ||
| 11938 | |||
| 11939 | /* set the temporary read_set */ | ||
| 11940 | 8655 | table->column_bitmaps_set_no_signal(&table->tmp_set, table->write_set); | |
| 11941 | } | ||
| 11942 | |||
| 11943 |
9/12✓ Branch 0 taken 22683569 times.
✓ Branch 1 taken 16233 times.
✓ Branch 2 taken 22699802 times.
✓ Branch 3 taken 5899159 times.
✓ Branch 4 taken 5899160 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 5899160 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 9 times.
✓ Branch 9 taken 5899151 times.
✓ Branch 10 taken 9 times.
✗ Branch 11 not taken.
|
28598961 | DBUG_PRINT_BITSET("debug", "table->read_set (after preparing): %s", |
| 11944 | table->read_set); | ||
| 11945 | 5899160 | } | |
| 11946 | |||
| 11947 | 71531837 | int THD::binlog_flush_pending_rows_event(bool stmt_end, bool is_transactional) { | |
| 11948 |
1/2✓ Branch 0 taken 71535080 times.
✗ Branch 1 not taken.
|
71531837 | DBUG_TRACE; |
| 11949 | /* | ||
| 11950 | We shall flush the pending event even if we are not in row-based | ||
| 11951 | mode: it might be the case that we left row-based mode before | ||
| 11952 | flushing anything (e.g., if we have explicitly locked tables). | ||
| 11953 | */ | ||
| 11954 | #ifdef WITH_WSREP | ||
| 11955 |
12/12✓ Branch 0 taken 28924496 times.
✓ Branch 1 taken 42610584 times.
✓ Branch 2 taken 2561906 times.
✓ Branch 3 taken 26362590 times.
✓ Branch 4 taken 1674184 times.
✓ Branch 5 taken 887722 times.
✓ Branch 6 taken 1661530 times.
✓ Branch 7 taken 12654 times.
✓ Branch 8 taken 30979604 times.
✓ Branch 9 taken 40541797 times.
✓ Branch 10 taken 30979604 times.
✓ Branch 11 taken 40554451 times.
|
71535080 | if (!(WSREP_EMULATE_BINLOG_NNULL(this) || mysql_bin_log.is_open())) return 0; |
| 11956 | #else | ||
| 11957 | if (!mysql_bin_log.is_open()) return 0; | ||
| 11958 | #endif /* WITH_WSREP */ | ||
| 11959 | |||
| 11960 | /* | ||
| 11961 | Mark the event as the last event of a statement if the stmt_end | ||
| 11962 | flag is set. | ||
| 11963 | */ | ||
| 11964 | 40554451 | int error = 0; | |
| 11965 | 40555154 | if (Rows_log_event *pending = | |
| 11966 |
3/4✓ Branch 0 taken 40555154 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4214335 times.
✓ Branch 3 taken 36340819 times.
|
40554451 | binlog_get_pending_rows_event(is_transactional)) { |
| 11967 |
1/2✓ Branch 0 taken 4214340 times.
✗ Branch 1 not taken.
|
4214335 | if (stmt_end) { |
| 11968 | 4214340 | pending->set_flags(Rows_log_event::STMT_END_F); | |
| 11969 | 4214282 | binlog_table_maps = 0; | |
| 11970 | } | ||
| 11971 | |||
| 11972 |
1/2✓ Branch 0 taken 4214358 times.
✗ Branch 1 not taken.
|
4214277 | error = mysql_bin_log.flush_and_set_pending_rows_event(this, nullptr, |
| 11973 | is_transactional); | ||
| 11974 | } | ||
| 11975 | |||
| 11976 | 40555177 | return error; | |
| 11977 | 71534781 | } | |
| 11978 | |||
| 11979 | #if !defined(NDEBUG) | ||
| 11980 | 117 | static const char *show_query_type(THD::enum_binlog_query_type qtype) { | |
| 11981 |
2/3✓ Branch 0 taken 27 times.
✓ Branch 1 taken 90 times.
✗ Branch 2 not taken.
|
117 | switch (qtype) { |
| 11982 | 27 | case THD::ROW_QUERY_TYPE: | |
| 11983 | 27 | return "ROW"; | |
| 11984 | 90 | case THD::STMT_QUERY_TYPE: | |
| 11985 | 90 | return "STMT"; | |
| 11986 | ✗ | case THD::QUERY_TYPE_COUNT: | |
| 11987 | default: | ||
| 11988 | ✗ | assert(0 <= qtype && qtype < THD::QUERY_TYPE_COUNT); | |
| 11989 | } | ||
| 11990 | static char buf[64]; | ||
| 11991 | ✗ | sprintf(buf, "UNKNOWN#%d", qtype); | |
| 11992 | ✗ | return buf; | |
| 11993 | } | ||
| 11994 | #endif | ||
| 11995 | |||
| 11996 | /** | ||
| 11997 | Auxiliary function to reset the limit unsafety warning suppression. | ||
| 11998 | */ | ||
| 11999 | ✗ | static void reset_binlog_unsafe_suppression() { | |
| 12000 | ✗ | DBUG_TRACE; | |
| 12001 | ✗ | unsafe_warning_suppression_is_activated = false; | |
| 12002 | ✗ | limit_unsafe_warning_count = 0; | |
| 12003 | ✗ | limit_unsafe_suppression_start_time = my_getsystime() / 10000000; | |
| 12004 | } | ||
| 12005 | |||
| 12006 | /** | ||
| 12007 | Auxiliary function to print warning in the error log. | ||
| 12008 | */ | ||
| 12009 | 2533 | static void print_unsafe_warning_to_log(int unsafe_type, char *buf, | |
| 12010 | const char *query) { | ||
| 12011 |
1/2✓ Branch 0 taken 2533 times.
✗ Branch 1 not taken.
|
2533 | DBUG_TRACE; |
| 12012 |
1/2✓ Branch 0 taken 2533 times.
✗ Branch 1 not taken.
|
2533 | sprintf(buf, ER_DEFAULT(ER_BINLOG_UNSAFE_STATEMENT), |
| 12013 |
1/2✓ Branch 0 taken 2533 times.
✗ Branch 1 not taken.
|
2533 | ER_DEFAULT_NONCONST(LEX::binlog_stmt_unsafe_errcode[unsafe_type])); |
| 12014 |
8/16✓ Branch 0 taken 2533 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2533 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2533 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2533 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2533 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 2533 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 2533 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 2533 times.
✗ Branch 15 not taken.
|
2533 | LogErr(WARNING_LEVEL, ER_BINLOG_UNSAFE_MESSAGE_AND_STATEMENT, buf, query); |
| 12015 | 2533 | } | |
| 12016 | |||
| 12017 | /** | ||
| 12018 | Auxiliary function to check if the warning for limit unsafety should be | ||
| 12019 | thrown or suppressed. Details of the implementation can be found in the | ||
| 12020 | comments inline. | ||
| 12021 | |||
| 12022 | @param buf Buffer to hold the warning message text | ||
| 12023 | @param unsafe_type The type of unsafety. | ||
| 12024 | @param query The actual query statement. | ||
| 12025 | |||
| 12026 | TODO: Remove this function and implement a general service for all warnings | ||
| 12027 | that would prevent flooding the error log. => switch to log_throttle class? | ||
| 12028 | */ | ||
| 12029 | 282 | static void do_unsafe_limit_checkout(char *buf, int unsafe_type, | |
| 12030 | const char *query) { | ||
| 12031 | ulonglong now; | ||
| 12032 |
1/2✓ Branch 0 taken 282 times.
✗ Branch 1 not taken.
|
282 | DBUG_TRACE; |
| 12033 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 282 times.
|
282 | assert(unsafe_type == LEX::BINLOG_STMT_UNSAFE_LIMIT); |
| 12034 | 282 | limit_unsafe_warning_count++; | |
| 12035 | /* | ||
| 12036 | INITIALIZING: | ||
| 12037 | If this is the first time this function is called with log warning | ||
| 12038 | enabled, the monitoring the unsafe warnings should start. | ||
| 12039 | */ | ||
| 12040 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 273 times.
|
282 | if (limit_unsafe_suppression_start_time == 0) { |
| 12041 | 9 | limit_unsafe_suppression_start_time = my_getsystime() / 10000000; | |
| 12042 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | print_unsafe_warning_to_log(unsafe_type, buf, query); |
| 12043 | } else { | ||
| 12044 |
1/2✓ Branch 0 taken 273 times.
✗ Branch 1 not taken.
|
273 | if (!unsafe_warning_suppression_is_activated) |
| 12045 |
1/2✓ Branch 0 taken 273 times.
✗ Branch 1 not taken.
|
273 | print_unsafe_warning_to_log(unsafe_type, buf, query); |
| 12046 | |||
| 12047 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 269 times.
|
273 | if (limit_unsafe_warning_count >= |
| 12048 | LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT) { | ||
| 12049 | 4 | now = my_getsystime() / 10000000; | |
| 12050 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | if (!unsafe_warning_suppression_is_activated) { |
| 12051 | /* | ||
| 12052 | ACTIVATION: | ||
| 12053 | We got LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT warnings in | ||
| 12054 | less than LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT we activate the | ||
| 12055 | suppression. | ||
| 12056 | */ | ||
| 12057 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if ((now - limit_unsafe_suppression_start_time) <= |
| 12058 | LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT) { | ||
| 12059 | ✗ | unsafe_warning_suppression_is_activated = true; | |
| 12060 | ✗ | DBUG_PRINT("info", ("A warning flood has been detected and the " | |
| 12061 | "limit unsafety warning suppression has been " | ||
| 12062 | "activated.")); | ||
| 12063 | } else { | ||
| 12064 | /* | ||
| 12065 | there is no flooding till now, therefore we restart the monitoring | ||
| 12066 | */ | ||
| 12067 | 4 | limit_unsafe_suppression_start_time = my_getsystime() / 10000000; | |
| 12068 | 4 | limit_unsafe_warning_count = 0; | |
| 12069 | } | ||
| 12070 | } else { | ||
| 12071 | /* | ||
| 12072 | Print the suppression note and the unsafe warning. | ||
| 12073 | */ | ||
| 12074 | ✗ | LogErr(INFORMATION_LEVEL, ER_BINLOG_WARNING_SUPPRESSED, | |
| 12075 | limit_unsafe_warning_count, | ||
| 12076 | (int)(now - limit_unsafe_suppression_start_time)); | ||
| 12077 | ✗ | print_unsafe_warning_to_log(unsafe_type, buf, query); | |
| 12078 | /* | ||
| 12079 | DEACTIVATION: We got LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT | ||
| 12080 | warnings in more than LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT, the | ||
| 12081 | suppression should be deactivated. | ||
| 12082 | */ | ||
| 12083 | ✗ | if ((now - limit_unsafe_suppression_start_time) > | |
| 12084 | LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT) { | ||
| 12085 | ✗ | reset_binlog_unsafe_suppression(); | |
| 12086 | ✗ | DBUG_PRINT("info", ("The limit unsafety warning supression has " | |
| 12087 | "been deactivated")); | ||
| 12088 | } | ||
| 12089 | } | ||
| 12090 | 4 | limit_unsafe_warning_count = 0; | |
| 12091 | } | ||
| 12092 | } | ||
| 12093 | 282 | } | |
| 12094 | |||
| 12095 | /** | ||
| 12096 | Auxiliary method used by @c binlog_query() to raise warnings. | ||
| 12097 | |||
| 12098 | The type of warning and the type of unsafeness is stored in | ||
| 12099 | THD::binlog_unsafe_warning_flags. | ||
| 12100 | */ | ||
| 12101 | 1533861 | void THD::issue_unsafe_warnings() { | |
| 12102 | char buf[MYSQL_ERRMSG_SIZE * 2]; | ||
| 12103 |
1/2✓ Branch 0 taken 1534070 times.
✗ Branch 1 not taken.
|
1533861 | DBUG_TRACE; |
| 12104 | /* | ||
| 12105 | Ensure that binlog_unsafe_warning_flags is big enough to hold all | ||
| 12106 | bits. This is actually a constant expression. | ||
| 12107 | */ | ||
| 12108 | assert(LEX::BINLOG_STMT_UNSAFE_COUNT <= | ||
| 12109 | sizeof(binlog_unsafe_warning_flags) * CHAR_BIT); | ||
| 12110 | |||
| 12111 | 1534070 | uint32 unsafe_type_flags = binlog_unsafe_warning_flags; | |
| 12112 | |||
| 12113 |
2/2✓ Branch 0 taken 577 times.
✓ Branch 1 taken 1533493 times.
|
1534070 | if ((unsafe_type_flags & (1U << LEX::BINLOG_STMT_UNSAFE_LIMIT)) != 0) { |
| 12114 |
2/2✓ Branch 0 taken 502 times.
✓ Branch 1 taken 75 times.
|
577 | if ((lex->sql_command == SQLCOM_DELETE || |
| 12115 |
2/2✓ Branch 0 taken 63 times.
✓ Branch 1 taken 439 times.
|
502 | lex->sql_command == SQLCOM_UPDATE) && |
| 12116 |
1/2✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
|
138 | lex->query_block->select_limit) { |
| 12117 | 276 | ORDER *order = (ORDER *)((lex->query_block->order_list.elements) | |
| 12118 |
2/2✓ Branch 0 taken 103 times.
✓ Branch 1 taken 35 times.
|
138 | ? lex->query_block->order_list.first |
| 12119 | : nullptr); | ||
| 12120 | 414 | if ((lex->query_block->select_limit && | |
| 12121 |
1/2✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
|
138 | lex->query_block->select_limit->fixed && |
| 12122 |
5/8✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 138 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 138 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 83 times.
✓ Branch 7 taken 55 times.
|
414 | lex->query_block->select_limit->val_int() == 0) || |
| 12123 |
3/4✓ Branch 0 taken 138 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 83 times.
✓ Branch 3 taken 55 times.
|
138 | is_order_deterministic(lex->query_tables, |
| 12124 | 138 | lex->query_block->where_cond(), order)) { | |
| 12125 | 83 | unsafe_type_flags &= ~(1U << LEX::BINLOG_STMT_UNSAFE_LIMIT); | |
| 12126 | } | ||
| 12127 | } | ||
| 12128 |
2/2✓ Branch 0 taken 230 times.
✓ Branch 1 taken 347 times.
|
577 | if ((lex->sql_command == SQLCOM_INSERT_SELECT || |
| 12129 |
2/2✓ Branch 0 taken 61 times.
✓ Branch 1 taken 169 times.
|
230 | lex->sql_command == SQLCOM_REPLACE_SELECT) && |
| 12130 |
2/2✓ Branch 0 taken 211 times.
✓ Branch 1 taken 197 times.
|
408 | order_deterministic) { |
| 12131 | 211 | unsafe_type_flags &= ~(1U << LEX::BINLOG_STMT_UNSAFE_LIMIT); | |
| 12132 | } | ||
| 12133 | } | ||
| 12134 | |||
| 12135 | /* | ||
| 12136 | For each unsafe_type, check if the statement is unsafe in this way | ||
| 12137 | and issue a warning. | ||
| 12138 | */ | ||
| 12139 |
2/2✓ Branch 0 taken 39878379 times.
✓ Branch 1 taken 1538066 times.
|
41416445 | for (int unsafe_type = 0; unsafe_type < LEX::BINLOG_STMT_UNSAFE_COUNT; |
| 12140 | unsafe_type++) { | ||
| 12141 |
2/2✓ Branch 0 taken 13133 times.
✓ Branch 1 taken 39865246 times.
|
39878379 | if ((unsafe_type_flags & (1 << unsafe_type)) != 0) { |
| 12142 |
2/4✓ Branch 0 taken 13133 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13133 times.
✗ Branch 3 not taken.
|
13133 | push_warning_printf( |
| 12143 | this, Sql_condition::SL_NOTE, ER_BINLOG_UNSAFE_STATEMENT, | ||
| 12144 | ER_THD(this, ER_BINLOG_UNSAFE_STATEMENT), | ||
| 12145 |
1/2✓ Branch 0 taken 13133 times.
✗ Branch 1 not taken.
|
13133 | ER_THD_NONCONST(this, LEX::binlog_stmt_unsafe_errcode[unsafe_type])); |
| 12146 |
4/4✓ Branch 0 taken 2534 times.
✓ Branch 1 taken 10599 times.
✓ Branch 2 taken 2533 times.
✓ Branch 3 taken 1 times.
|
13133 | if (log_error_verbosity > 1 && opt_log_unsafe_statements) { |
| 12147 |
2/2✓ Branch 0 taken 282 times.
✓ Branch 1 taken 2251 times.
|
2533 | if (unsafe_type == LEX::BINLOG_STMT_UNSAFE_LIMIT) |
| 12148 |
2/4✓ Branch 0 taken 282 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 282 times.
✗ Branch 3 not taken.
|
282 | do_unsafe_limit_checkout(buf, unsafe_type, query().str); |
| 12149 | else // cases other than LIMIT unsafety | ||
| 12150 |
2/4✓ Branch 0 taken 2251 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6247 times.
✗ Branch 3 not taken.
|
2251 | print_unsafe_warning_to_log(unsafe_type, buf, query().str); |
| 12151 | } | ||
| 12152 | } | ||
| 12153 | } | ||
| 12154 | 1538066 | } | |
| 12155 | |||
| 12156 | /** | ||
| 12157 | Log the current query. | ||
| 12158 | |||
| 12159 | The query will be logged in either row format or statement format | ||
| 12160 | depending on the value of @c current_stmt_binlog_format_row field and | ||
| 12161 | the value of the @c qtype parameter. | ||
| 12162 | |||
| 12163 | This function must be called: | ||
| 12164 | |||
| 12165 | - After the all calls to ha_*_row() functions have been issued. | ||
| 12166 | |||
| 12167 | - After any writes to system tables. Rationale: if system tables | ||
| 12168 | were written after a call to this function, and the master crashes | ||
| 12169 | after the call to this function and before writing the system | ||
| 12170 | tables, then the master and slave get out of sync. | ||
| 12171 | |||
| 12172 | - Before tables are unlocked and closed. | ||
| 12173 | |||
| 12174 | @see decide_logging_format | ||
| 12175 | |||
| 12176 | @retval 0 Success | ||
| 12177 | |||
| 12178 | @retval nonzero If there is a failure when writing the query (e.g., | ||
| 12179 | write failure), then the error code is returned. | ||
| 12180 | */ | ||
| 12181 | 5020840 | int THD::binlog_query(THD::enum_binlog_query_type qtype, const char *query_arg, | |
| 12182 | size_t query_len, bool is_trans, bool direct, | ||
| 12183 | bool suppress_use, int errcode) { | ||
| 12184 |
1/2✓ Branch 0 taken 5021262 times.
✗ Branch 1 not taken.
|
5020840 | DBUG_TRACE; |
| 12185 |
4/8✓ Branch 0 taken 5021211 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5021217 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 117 times.
✓ Branch 5 taken 5021100 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
5021262 | DBUG_PRINT("enter", |
| 12186 | ("qtype: %s query: '%s'", show_query_type(qtype), query_arg)); | ||
| 12187 | #ifdef WITH_WSREP | ||
| 12188 |
10/12✓ Branch 0 taken 5021017 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 52433 times.
✓ Branch 3 taken 4968584 times.
✓ Branch 4 taken 52418 times.
✓ Branch 5 taken 15 times.
✓ Branch 6 taken 42507 times.
✓ Branch 7 taken 9911 times.
✓ Branch 8 taken 42387 times.
✓ Branch 9 taken 120 times.
✓ Branch 10 taken 5020979 times.
✗ Branch 11 not taken.
|
5021017 | assert(query_arg && |
| 12189 | (WSREP_EMULATE_BINLOG_NNULL(this) || mysql_bin_log.is_open())); | ||
| 12190 | #else | ||
| 12191 | assert(query_arg && mysql_bin_log.is_open()); | ||
| 12192 | #endif /* WITH_WSREP */ | ||
| 12193 | |||
| 12194 |
2/2✓ Branch 0 taken 7744 times.
✓ Branch 1 taken 5013371 times.
|
5021099 | if (get_binlog_local_stmt_filter() == BINLOG_FILTER_SET) { |
| 12195 | /* | ||
| 12196 | The current statement is to be ignored, and not written to | ||
| 12197 | the binlog. Do not call issue_unsafe_warnings(). | ||
| 12198 | */ | ||
| 12199 | 7744 | return 0; | |
| 12200 | } | ||
| 12201 | |||
| 12202 | /* | ||
| 12203 | If we are not in prelocked mode, mysql_unlock_tables() will be | ||
| 12204 | called after this binlog_query(), so we have to flush the pending | ||
| 12205 | rows event with the STMT_END_F set to unlock all tables at the | ||
| 12206 | slave side as well. | ||
| 12207 | |||
| 12208 | If we are in prelocked mode, the flushing will be done inside the | ||
| 12209 | top-most close_thread_tables(). | ||
| 12210 | */ | ||
| 12211 |
2/2✓ Branch 0 taken 4914890 times.
✓ Branch 1 taken 98481 times.
|
5013371 | if (this->locked_tables_mode <= LTM_LOCK_TABLES) |
| 12212 |
3/4✓ Branch 0 taken 4914978 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
✓ Branch 3 taken 4914955 times.
|
4914890 | if (int error = binlog_flush_pending_rows_event(true, is_trans)) |
| 12213 | 23 | return error; | |
| 12214 | |||
| 12215 | /* | ||
| 12216 | Warnings for unsafe statements logged in statement format are | ||
| 12217 | printed in three places instead of in decide_logging_format(). | ||
| 12218 | This is because the warnings should be printed only if the statement | ||
| 12219 | is actually logged. When executing decide_logging_format(), we cannot | ||
| 12220 | know for sure if the statement will be logged: | ||
| 12221 | |||
| 12222 | 1 - sp_head::execute_procedure which prints out warnings for calls to | ||
| 12223 | stored procedures. | ||
| 12224 | |||
| 12225 | 2 - sp_head::execute_function which prints out warnings for calls | ||
| 12226 | involving functions. | ||
| 12227 | |||
| 12228 | 3 - THD::binlog_query (here) which prints warning for top level | ||
| 12229 | statements not covered by the two cases above: i.e., if not inside a | ||
| 12230 | procedure and a function. | ||
| 12231 | |||
| 12232 | Besides, we should not try to print these warnings if it is not | ||
| 12233 | possible to write statements to the binary log as it happens when | ||
| 12234 | the execution is inside a function, or generally speaking, when | ||
| 12235 | the variables.option_bits & OPTION_BIN_LOG is false. | ||
| 12236 | */ | ||
| 12237 |
4/4✓ Branch 0 taken 4768100 times.
✓ Branch 1 taken 245336 times.
✓ Branch 2 taken 1524608 times.
✓ Branch 3 taken 3243492 times.
|
5013436 | if ((variables.option_bits & OPTION_BIN_LOG) && sp_runtime_ctx == nullptr && |
| 12238 |
1/2✓ Branch 0 taken 1524844 times.
✗ Branch 1 not taken.
|
1524608 | !binlog_evt_union.do_union) { |
| 12239 |
1/2✓ Branch 0 taken 1524868 times.
✗ Branch 1 not taken.
|
1524844 | issue_unsafe_warnings(); |
| 12240 | 1524868 | order_deterministic = true; | |
| 12241 | } | ||
| 12242 | |||
| 12243 |
2/3✓ Branch 0 taken 4546166 times.
✓ Branch 1 taken 467294 times.
✗ Branch 2 not taken.
|
5013460 | switch (qtype) { |
| 12244 | /* | ||
| 12245 | ROW_QUERY_TYPE means that the statement may be logged either in | ||
| 12246 | row format or in statement format. If | ||
| 12247 | current_stmt_binlog_format is row, it means that the | ||
| 12248 | statement has already been logged in row format and hence shall | ||
| 12249 | not be logged again. | ||
| 12250 | */ | ||
| 12251 | 4546166 | case THD::ROW_QUERY_TYPE: | |
| 12252 |
5/8✓ Branch 0 taken 4546157 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4546171 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 27 times.
✓ Branch 5 taken 4546144 times.
✓ Branch 6 taken 27 times.
✗ Branch 7 not taken.
|
4546166 | DBUG_PRINT("debug", ("is_current_stmt_binlog_format_row: %d", |
| 12253 | is_current_stmt_binlog_format_row())); | ||
| 12254 |
2/2✓ Branch 0 taken 4168819 times.
✓ Branch 1 taken 377330 times.
|
4546171 | if (is_current_stmt_binlog_format_row()) return 0; |
| 12255 | [[fallthrough]]; | ||
| 12256 | |||
| 12257 | /* | ||
| 12258 | STMT_QUERY_TYPE means that the query must be logged in statement | ||
| 12259 | format; it cannot be logged in row format. This is typically | ||
| 12260 | used by DDL statements. It is an error to use this query type | ||
| 12261 | if current_stmt_binlog_format_row is row. | ||
| 12262 | |||
| 12263 | @todo Currently there are places that call this method with | ||
| 12264 | STMT_QUERY_TYPE and current_stmt_binlog_format is row. Fix those | ||
| 12265 | places and add assert to ensure correct behavior. /Sven | ||
| 12266 | */ | ||
| 12267 | case THD::STMT_QUERY_TYPE: | ||
| 12268 | /* | ||
| 12269 | The MYSQL_BIN_LOG::write() function will set the STMT_END_F flag and | ||
| 12270 | flush the pending rows event if necessary. | ||
| 12271 | */ | ||
| 12272 | { | ||
| 12273 | Query_log_event qinfo(this, query_arg, query_len, is_trans, direct, | ||
| 12274 |
1/2✓ Branch 0 taken 844439 times.
✗ Branch 1 not taken.
|
844624 | suppress_use, errcode); |
| 12275 | /* | ||
| 12276 | Binlog table maps will be irrelevant after a Query_log_event | ||
| 12277 | (they are just removed on the slave side) so after the query | ||
| 12278 | log event is written to the binary log, we pretend that no | ||
| 12279 | table maps were written. | ||
| 12280 | */ | ||
| 12281 |
1/2✓ Branch 0 taken 844553 times.
✗ Branch 1 not taken.
|
844439 | int error = mysql_bin_log.write_event(&qinfo); |
| 12282 | 844553 | binlog_table_maps = 0; | |
| 12283 | 844553 | return error; | |
| 12284 | 844553 | } | |
| 12285 | break; | ||
| 12286 | |||
| 12287 | ✗ | case THD::QUERY_TYPE_COUNT: | |
| 12288 | default: | ||
| 12289 | ✗ | assert(0 <= qtype && qtype < QUERY_TYPE_COUNT); | |
| 12290 | } | ||
| 12291 | ✗ | return 0; | |
| 12292 | 5021247 | } | |
| 12293 | |||
| 12294 | #ifdef WITH_WSREP | ||
| 12295 | 52212 | int prepend_binlog_control_event(THD *const thd) { | |
| 12296 | 52212 | unsigned char *read_pos = nullptr; | |
| 12297 | 52212 | my_off_t read_len = 0; | |
| 12298 | |||
| 12299 |
2/2✓ Branch 0 taken 52196 times.
✓ Branch 1 taken 16 times.
|
52212 | if ((thd->variables.option_bits & OPTION_BIN_LOG) != 0) return 0; |
| 12300 | |||
| 12301 |
1/2✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
|
16 | IO_CACHE_binlog_cache_storage tmp_io_cache; |
| 12302 |
3/6✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 16 times.
|
16 | if (tmp_io_cache.open(mysql_tmpdir, TEMP_PREFIX, 128, 128)) |
| 12303 | ✗ | return ER_ERROR_ON_WRITE; | |
| 12304 | |||
| 12305 | 16 | int ret = 0; | |
| 12306 |
1/2✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
|
16 | Intvar_log_event ev((uchar)binary_log::Intvar_event::BINLOG_CONTROL_EVENT, 0); |
| 12307 |
2/4✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
|
16 | if (ev.write(&tmp_io_cache)) { |
| 12308 | ✗ | ret = ER_ERROR_ON_WRITE; | |
| 12309 | ✗ | goto cleanup; | |
| 12310 | } | ||
| 12311 | |||
| 12312 |
2/4✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
|
16 | if (tmp_io_cache.begin(&read_pos, &read_len)) { |
| 12313 | ✗ | WSREP_ERROR("Failed to initialize io-cache"); | |
| 12314 | ✗ | ret = ER_ERROR_ON_WRITE; | |
| 12315 | ✗ | goto cleanup; | |
| 12316 | } | ||
| 12317 | |||
| 12318 |
2/8✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 16 times.
|
16 | if (read_len == 0 && tmp_io_cache.next(&read_pos, &read_len)) { |
| 12319 | ✗ | WSREP_ERROR("Failed to read from io-cache"); | |
| 12320 | ✗ | ret = ER_ERROR_ON_WRITE; | |
| 12321 | ✗ | goto cleanup; | |
| 12322 | } | ||
| 12323 | |||
| 12324 |
2/4✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
✗ Branch 3 not taken.
|
16 | if (thd->wsrep_cs().append_data(wsrep::const_buffer(read_pos, read_len))) { |
| 12325 | ✗ | WSREP_ERROR("Failed to append writeset data"); | |
| 12326 | ✗ | ret = ER_ERROR_ON_WRITE; | |
| 12327 | } | ||
| 12328 | |||
| 12329 | 16 | cleanup: | |
| 12330 |
1/2✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
|
16 | tmp_io_cache.close(); |
| 12331 | 16 | return ret; | |
| 12332 | 16 | } | |
| 12333 | |||
| 12334 | 965608 | IO_CACHE_binlog_cache_storage *wsrep_get_trans_cache(THD *thd, | |
| 12335 | bool transaction) { | ||
| 12336 | 965608 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); | |
| 12337 |
1/2✓ Branch 0 taken 965609 times.
✗ Branch 1 not taken.
|
965609 | if (cache_mngr) { |
| 12338 |
1/2✓ Branch 0 taken 965609 times.
✗ Branch 1 not taken.
|
965609 | if (transaction) |
| 12339 | 965609 | return cache_mngr->get_trx_cache()->io_cache(); | |
| 12340 | else | ||
| 12341 | ✗ | return cache_mngr->get_stmt_cache()->io_cache(); | |
| 12342 | } else { | ||
| 12343 | ✗ | WSREP_DEBUG("binlog cache not initialized, conn :%u", thd->thread_id()); | |
| 12344 | ✗ | return NULL; | |
| 12345 | } | ||
| 12346 | } | ||
| 12347 | |||
| 12348 | ✗ | bool wsrep_trans_cache_is_empty(THD *thd) { | |
| 12349 | binlog_cache_mngr *const cache_mngr = | ||
| 12350 | ✗ | (binlog_cache_mngr *)thd_get_ha_data(thd, binlog_hton); | |
| 12351 | ✗ | return (!cache_mngr || cache_mngr->trx_cache.is_binlog_empty()); | |
| 12352 | } | ||
| 12353 | |||
| 12354 | ✗ | void wsrep_thd_binlog_flush_pending_rows_event(THD *thd, bool stmt_end) { | |
| 12355 | ✗ | thd->binlog_flush_pending_rows_event(stmt_end); | |
| 12356 | } | ||
| 12357 | |||
| 12358 | 3979 | void wsrep_thd_binlog_trx_reset(THD *thd) { | |
| 12359 | /* | ||
| 12360 | TODO: fix autocommit select to not call the caller | ||
| 12361 | */ | ||
| 12362 |
2/2✓ Branch 0 taken 293 times.
✓ Branch 1 taken 3686 times.
|
3979 | if (thd_get_ha_data(thd, binlog_hton) != NULL) { |
| 12363 | 293 | binlog_cache_mngr *const cache_mngr = thd_get_cache_mngr(thd); | |
| 12364 |
1/2✓ Branch 0 taken 293 times.
✗ Branch 1 not taken.
|
293 | if (cache_mngr) { |
| 12365 | 293 | cache_mngr->trx_cache.reset(); | |
| 12366 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 293 times.
|
293 | if (!cache_mngr->stmt_cache.is_binlog_empty()) { |
| 12367 | ✗ | WSREP_DEBUG("pending events in stmt cache, sql: %s", WSREP_QUERY(thd)); | |
| 12368 | ✗ | cache_mngr->stmt_cache.reset(); | |
| 12369 | } | ||
| 12370 | } | ||
| 12371 | } | ||
| 12372 | 3979 | thd->clear_binlog_table_maps(); | |
| 12373 | 3979 | } | |
| 12374 | |||
| 12375 | 7933491 | TC_LOG::enum_result wsrep_thd_binlog_commit(THD *thd, bool all) { | |
| 12376 | /* binlog commit is called for wsrep replication to happen | ||
| 12377 | - applier and replayer can skip binlog commit | ||
| 12378 | - also if node is not joined, replication must be skipped | ||
| 12379 | */ | ||
| 12380 |
13/14✓ Branch 0 taken 7933494 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5326401 times.
✓ Branch 3 taken 2607093 times.
✓ Branch 4 taken 127629 times.
✓ Branch 5 taken 5198772 times.
✓ Branch 6 taken 17952 times.
✓ Branch 7 taken 109677 times.
✓ Branch 8 taken 4728 times.
✓ Branch 9 taken 13224 times.
✓ Branch 10 taken 4480 times.
✓ Branch 11 taken 248 times.
✓ Branch 12 taken 3147 times.
✓ Branch 13 taken 7930347 times.
|
7937974 | if (WSREP_EMULATE_BINLOG(thd) && !wsrep_thd_is_applying(thd) && |
| 12381 |
2/2✓ Branch 0 taken 3147 times.
✓ Branch 1 taken 1336 times.
|
4480 | wsrep_ready_get()) |
| 12382 | 3147 | return mysql_bin_log.commit(thd, all); | |
| 12383 | else { | ||
| 12384 |
2/2✓ Branch 0 taken 2304853 times.
✓ Branch 1 taken 5625494 times.
|
7930347 | if (all) { |
| 12385 |
2/4✓ Branch 0 taken 2304867 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2304888 times.
✗ Branch 3 not taken.
|
2304853 | CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_commit_in_tc"); |
| 12386 | } | ||
| 12387 |
2/2✓ Branch 0 taken 57 times.
✓ Branch 1 taken 7930310 times.
|
7930386 | return trx_coordinator::commit_in_engines(thd, all) ? TC_LOG::RESULT_ABORTED |
| 12388 | 7930367 | : TC_LOG::RESULT_SUCCESS; | |
| 12389 | } | ||
| 12390 | } | ||
| 12391 | |||
| 12392 | 267761 | int wsrep_thd_binlog_rollback(THD *thd, bool all) { | |
| 12393 | /* binlog rollback is called for wsrep replication to happen | ||
| 12394 | - applier and replayer can skip binlog commit | ||
| 12395 | - also if node is not joined, replication must be skipped | ||
| 12396 | */ | ||
| 12397 |
13/14✓ Branch 0 taken 267762 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 237164 times.
✓ Branch 3 taken 30598 times.
✓ Branch 4 taken 10369 times.
✓ Branch 5 taken 226795 times.
✓ Branch 6 taken 8500 times.
✓ Branch 7 taken 1869 times.
✓ Branch 8 taken 1581 times.
✓ Branch 9 taken 6919 times.
✓ Branch 10 taken 1576 times.
✓ Branch 11 taken 4 times.
✓ Branch 12 taken 705 times.
✓ Branch 13 taken 267060 times.
|
269342 | if (WSREP_EMULATE_BINLOG(thd) && !wsrep_thd_is_applying(thd) && |
| 12398 |
2/2✓ Branch 0 taken 705 times.
✓ Branch 1 taken 876 times.
|
1576 | wsrep_ready_get()) |
| 12399 | 705 | return mysql_bin_log.rollback(thd, all); | |
| 12400 | else { | ||
| 12401 |
2/2✓ Branch 0 taken 230505 times.
✓ Branch 1 taken 36555 times.
|
267060 | if (all) { |
| 12402 |
2/4✓ Branch 0 taken 230521 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 230505 times.
✗ Branch 3 not taken.
|
230505 | CONDITIONAL_SYNC_POINT_FOR_TIMESTAMP("before_rollback_in_tc"); |
| 12403 | } | ||
| 12404 | 267069 | return trx_coordinator::rollback_in_engines(thd, all); | |
| 12405 | } | ||
| 12406 | } | ||
| 12407 | |||
| 12408 | 6 | bool wsrep_stmt_rollback_is_safe(THD *thd) { | |
| 12409 | 6 | bool ret(true); | |
| 12410 | |||
| 12411 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | DBUG_TRACE; |
| 12412 | |||
| 12413 | binlog_cache_mngr *cache_mngr = | ||
| 12414 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | (binlog_cache_mngr *)thd_get_ha_data(thd, binlog_hton); |
| 12415 | |||
| 12416 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
6 | if (binlog_hton && cache_mngr) { |
| 12417 |
4/6✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
|
14 | if (thd->wsrep_sr().fragments_certified() > 0 && |
| 12418 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
8 | (cache_mngr->trx_cache.get_prev_position() == MY_OFF_T_UNDEF || |
| 12419 | 2 | cache_mngr->trx_cache.get_prev_position() < | |
| 12420 | 2 | thd->wsrep_sr().log_position())) { | |
| 12421 |
1/26✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
|
6 | WSREP_DEBUG( |
| 12422 | "statement rollback is not safe for streaming replication" | ||
| 12423 | " pre-stmt_pos: %llu, frag repl pos: %zu\n" | ||
| 12424 | "Thread: %u, SQL: %s", | ||
| 12425 | cache_mngr->trx_cache.get_prev_position(), | ||
| 12426 | thd->wsrep_sr().log_position(), thd->thread_id(), thd->query().str); | ||
| 12427 | 6 | ret = false; | |
| 12428 | } | ||
| 12429 | } | ||
| 12430 | 6 | return ret; | |
| 12431 | 6 | } | |
| 12432 | |||
| 12433 | ✗ | void wsrep_register_binlog_handler(THD *thd, bool trx) { | |
| 12434 | ✗ | DBUG_TRACE; | |
| 12435 | /* | ||
| 12436 | If this is the first call to this function while processing a statement, | ||
| 12437 | the transactional cache does not have a savepoint defined. So, in what | ||
| 12438 | follows: | ||
| 12439 | . an implicit savepoint is defined; | ||
| 12440 | . callbacks are registered; | ||
| 12441 | . binary log is set as read/write. | ||
| 12442 | |||
| 12443 | The savepoint allows for truncating the trx-cache transactional changes | ||
| 12444 | fail. Callbacks are necessary to flush caches upon committing or rolling | ||
| 12445 | back a statement or a transaction. However, notifications do not happen | ||
| 12446 | if the binary log is set as read/write. | ||
| 12447 | */ | ||
| 12448 | // binlog_cache_mngr *cache_mngr= thd_get_cache_mngr(thd); | ||
| 12449 | binlog_cache_mngr *cache_mngr = | ||
| 12450 | ✗ | (binlog_cache_mngr *)thd_get_ha_data(thd, binlog_hton); | |
| 12451 | /* cache_mngr may be missing e.g. in mtr test ev51914.test */ | ||
| 12452 | ✗ | if (cache_mngr && | |
| 12453 | ✗ | cache_mngr->trx_cache.get_prev_position() == MY_OFF_T_UNDEF) { | |
| 12454 | /* | ||
| 12455 | Set an implicit savepoint in order to be able to truncate a trx-cache. | ||
| 12456 | */ | ||
| 12457 | ✗ | my_off_t pos = 0; | |
| 12458 | ✗ | binlog_trans_log_savepos(thd, &pos); | |
| 12459 | ✗ | cache_mngr->trx_cache.set_prev_position(pos); | |
| 12460 | |||
| 12461 | /* | ||
| 12462 | Set callbacks in order to be able to call commmit or rollback. | ||
| 12463 | */ | ||
| 12464 | ✗ | if (trx) trans_register_ha(thd, true, binlog_hton, NULL); | |
| 12465 | ✗ | trans_register_ha(thd, false, binlog_hton, NULL); | |
| 12466 | |||
| 12467 | /* | ||
| 12468 | Set the binary log as read/write otherwise callbacks are not called. | ||
| 12469 | */ | ||
| 12470 | ✗ | thd->get_ha_data(binlog_hton->slot)->ha_info[0].set_trx_read_write(); | |
| 12471 | } | ||
| 12472 | ✗ | return; | |
| 12473 | } | ||
| 12474 | |||
| 12475 | #endif /* WITH_WSREP */ | ||
| 12476 | |||
| 12477 | 284402 | static const binlog_cache_mngr *get_cache_mngr(THD *thd) { | |
| 12478 | const binlog_cache_mngr *cache_mngr = | ||
| 12479 |
2/2✓ Branch 0 taken 280510 times.
✓ Branch 1 taken 3892 times.
|
284402 | (thd && opt_bin_log) |
| 12480 |
1/2✓ Branch 0 taken 284402 times.
✗ Branch 1 not taken.
|
568804 | ? static_cast<binlog_cache_mngr *>(thd_get_ha_data(thd, binlog_hton)) |
| 12481 | 284402 | : nullptr; | |
| 12482 | |||
| 12483 | 284402 | return cache_mngr; | |
| 12484 | } | ||
| 12485 | |||
| 12486 | 142201 | static int show_binlog_vars(THD *thd, SHOW_VAR *var, | |
| 12487 | char *buff [[maybe_unused]]) { | ||
| 12488 | mysql_mutex_assert_owner(&LOCK_status); | ||
| 12489 | |||
| 12490 | 142201 | const binlog_cache_mngr *cache_mngr = get_cache_mngr(thd); | |
| 12491 | |||
| 12492 |
6/6✓ Branch 0 taken 19529 times.
✓ Branch 1 taken 122672 times.
✓ Branch 2 taken 48 times.
✓ Branch 3 taken 19481 times.
✓ Branch 4 taken 48 times.
✓ Branch 5 taken 142153 times.
|
142201 | if (cache_mngr && cache_mngr->has_consistent_snapshot()) { |
| 12493 | 48 | set_binlog_snapshot_file(cache_mngr->binlog_info.log_file_name); | |
| 12494 | 48 | binlog_snapshot_position = cache_mngr->binlog_info.pos; | |
| 12495 |
2/2✓ Branch 0 taken 140207 times.
✓ Branch 1 taken 1946 times.
|
142153 | } else if (mysql_bin_log.is_open()) { |
| 12496 | 140207 | set_binlog_snapshot_file(binlog_global_snapshot_file); | |
| 12497 | 140207 | binlog_snapshot_position = binlog_global_snapshot_position; | |
| 12498 | } else { | ||
| 12499 | 1946 | binlog_snapshot_file[0] = '\0'; | |
| 12500 | 1946 | binlog_snapshot_position = 0; | |
| 12501 | } | ||
| 12502 | 142201 | var->type = SHOW_ARRAY; | |
| 12503 | 142201 | var->value = reinterpret_cast<char *>(&binlog_status_vars_detail); | |
| 12504 | 142201 | return 0; | |
| 12505 | } | ||
| 12506 | |||
| 12507 | 142201 | static int show_binlog_snapshot_gtid_executed( | |
| 12508 | THD *thd, SHOW_VAR *var, char *buff [[maybe_unused]]) { | ||
| 12509 | mysql_mutex_assert_owner(&LOCK_status); | ||
| 12510 | |||
| 12511 | 142201 | const binlog_cache_mngr *cache_mngr = get_cache_mngr(thd); | |
| 12512 | |||
| 12513 |
6/6✓ Branch 0 taken 19529 times.
✓ Branch 1 taken 122672 times.
✓ Branch 2 taken 48 times.
✓ Branch 3 taken 19481 times.
✓ Branch 4 taken 48 times.
✓ Branch 5 taken 142153 times.
|
142201 | if (cache_mngr && cache_mngr->has_consistent_snapshot()) { |
| 12514 | 48 | binlog_snapshot_gtid_executed = cache_mngr->snapshot_gtid_executed; | |
| 12515 |
2/2✓ Branch 0 taken 140207 times.
✓ Branch 1 taken 1946 times.
|
142153 | } else if (mysql_bin_log.is_open()) { |
| 12516 | 140207 | binlog_snapshot_gtid_executed = "not-in-consistent-snapshot"; | |
| 12517 | } else { | ||
| 12518 | 1946 | binlog_snapshot_gtid_executed.clear(); | |
| 12519 | } | ||
| 12520 | |||
| 12521 | 142201 | var->type = SHOW_CHAR; | |
| 12522 | 142201 | var->value = const_cast<char *>(binlog_snapshot_gtid_executed.c_str()); | |
| 12523 | 142201 | return 0; | |
| 12524 | } | ||
| 12525 | |||
| 12526 | static SHOW_VAR binlog_status_vars_top[] = { | ||
| 12527 | {"Binlog", (char *)&show_binlog_vars, SHOW_FUNC, SHOW_SCOPE_GLOBAL}, | ||
| 12528 | {"Binlog_snapshot_gtid_executed", | ||
| 12529 | (char *)&show_binlog_snapshot_gtid_executed, SHOW_FUNC, SHOW_SCOPE_GLOBAL}, | ||
| 12530 | {NullS, NullS, SHOW_LONG, SHOW_SCOPE_GLOBAL}}; | ||
| 12531 | |||
| 12532 | namespace { | ||
| 12533 | 5168894 | void finish_transaction_in_engines(THD *thd, bool all, bool run_after_commit) { | |
| 12534 |
2/2✓ Branch 0 taken 2583784 times.
✓ Branch 1 taken 2585030 times.
|
5168894 | if (thd->get_transaction()->m_flags.commit_low) { |
| 12535 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2583782 times.
|
2583784 | if (trx_coordinator::commit_in_engines(thd, all, run_after_commit)) |
| 12536 | ✗ | thd->commit_error = THD::CE_COMMIT_ERROR; | |
| 12537 |
2/2✓ Branch 0 taken 289 times.
✓ Branch 1 taken 2585140 times.
|
2585030 | } else if (is_xa_rollback(thd)) { |
| 12538 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 289 times.
|
289 | if (trx_coordinator::rollback_in_engines(thd, all)) |
| 12539 | ✗ | thd->commit_error = THD::CE_COMMIT_ERROR; | |
| 12540 | } | ||
| 12541 | 5169211 | } | |
| 12542 | } // namespace | ||
| 12543 | |||
| 12544 | struct st_mysql_storage_engine binlog_storage_engine = { | ||
| 12545 | MYSQL_HANDLERTON_INTERFACE_VERSION}; | ||
| 12546 | |||
| 12547 | /** @} */ | ||
| 12548 | |||
| 12549 | mysql_declare_plugin(binlog){ | ||
| 12550 | MYSQL_STORAGE_ENGINE_PLUGIN, | ||
| 12551 | &binlog_storage_engine, | ||
| 12552 | "binlog", | ||
| 12553 | PLUGIN_AUTHOR_ORACLE, | ||
| 12554 | "This is a pseudo storage engine to represent the binlog in a transaction", | ||
| 12555 | PLUGIN_LICENSE_GPL, | ||
| 12556 | binlog_init, /* Plugin Init */ | ||
| 12557 | nullptr, /* Plugin Check uninstall */ | ||
| 12558 | binlog_deinit, /* Plugin Deinit */ | ||
| 12559 | 0x0100 /* 1.0 */, | ||
| 12560 | binlog_status_vars_top, /* status variables */ | ||
| 12561 | nullptr, /* system variables */ | ||
| 12562 | nullptr, /* config options */ | ||
| 12563 | 0, | ||
| 12564 | } mysql_declare_plugin_end; | ||
| 12565 |